Upload 4 files

server/db/db.py

@@ -1,5 +1,7 @@
 import streamlit as st
 import psycopg2
+import sqlite3
+from sqlite3 import Connection
 from datetime import datetime
 import logging
 from typing import List, Dict
@@ -10,62 +12,206 @@ logging.basicConfig(level=logging.INFO, handlers=[logging.StreamHandler()])
 logger = logging.getLogger(__name__)
 
 
-
 # Fonction pour obtenir la connexion à la base de données
-def get_db_connection():
+# def get_db_connection():
+#     try:
+#         conn = psycopg2.connect(
+#             host=st.secrets["DB_HOST"],
+#             port=st.secrets["DB_PORT"],
+#             dbname=st.secrets["DB_NAME"],
+#             user=st.secrets["DB_USER"],
+#             password=st.secrets["DB_PASSWORD"]
+#         )
+#         return conn
+#     except Exception as e:
+#         logger.error(f"Erreur de connexion à la base de données: {e}")
+#         return None
+
+
+def get_db_connection() -> Connection:
+    """
+    Établit une connexion avec la base SQLite.
+
+    Returns:
+        Connection : le client de connexion à la base.
+    """
     try:
-        conn = psycopg2.connect(
-            host=st.secrets["DB_HOST"],
-            port=st.secrets["DB_PORT"],
-            dbname=st.secrets["DB_NAME"],
-            user=st.secrets["DB_USER"],
-            password=st.secrets["DB_PASSWORD"]
-        )
+        conn = sqlite3.connect(
+            st.secrets["DB_NAME"], check_same_thread=False
+        )  # Spécifiez ici le chemin de votre fichier SQLite
+        conn.row_factory = sqlite3.Row  # Pour des résultats sous forme de dictionnaire
         return conn
-    except Exception as e:
-        logger.error(f"Erreur de connexion à la base de données: {e}")
+    except sqlite3.Error as e:
+        logger.error(f"Erreur de connexion à la base de données SQLite: {e}")
         return None
 
+
 # Connexion à la base de données pour récupérer le nombre total de recettes
-def get_recipes_count():
+# def get_recipes_count():
+#     conn = get_db_connection()
+#     if conn is None:
+#         return 0
+#     try:
+#         cursor = conn.cursor()
+#         cursor.execute("SELECT COUNT(*) FROM suggestions_repas")
+#         result = cursor.fetchone()
+#         return result[0]  # Le nombre total de recettes
+#     except Exception as e:
+#         logger.error(f"Erreur lors de la récupération du nombre de recettes : {e}")
+#         return 0
+#     finally:
+#         cursor.close()
+#         conn.close()
+
+
+def get_recipes_count() -> int:
+    """
+    Récupère le nombre total de recettes enregistrées dans la table `suggestions_repas` de la base de données SQLite.
+    
+    Cette fonction se connecte à la base de données SQLite, exécute une requête pour compter le nombre d'entrées
+    dans la table `suggestions_repas`, puis retourne ce nombre.
+    
+    Returns:
+        int: Le nombre total de recettes dans la table `suggestions_repas`. Retourne 0 en cas d'erreur ou si la connexion échoue.
+    """
+    # Connexion à la base de données SQLite
     conn = get_db_connection()
+
+    # Si la connexion échoue, on retourne 0
     if conn is None:
         return 0
+
     try:
+        # Création du curseur pour exécuter la requête
         cursor = conn.cursor()
+
+        # Exécution de la requête SQL pour compter les entrées de recettes dans la table 'suggestions_repas'
         cursor.execute("SELECT COUNT(*) FROM suggestions_repas")
+
+        # Récupération du résultat de la requête
         result = cursor.fetchone()
+
+        # Retour du nombre total de recettes
         return result[0]  # Le nombre total de recettes
-    except Exception as e:
+
+    except sqlite3.Error as e:
+        # En cas d'erreur, on enregistre l'erreur dans les logs et on retourne 0
         logger.error(f"Erreur lors de la récupération du nombre de recettes : {e}")
         return 0
+
     finally:
+        # Fermeture du curseur et de la connexion
         cursor.close()
         conn.close()
 
+
 # Fonction pour récupérer la latence moyenne des messages
-def get_average_latency():
+# def get_average_latency():
+#     conn = get_db_connection()
+#     if conn is None:
+#         return 0.0
+#     try:
+#         cursor = conn.cursor()
+#         cursor.execute("SELECT AVG(temps_traitement) FROM messages WHERE temps_traitement IS NOT NULL")
+#         result = cursor.fetchone()
+#         return round(result[0], 2) if result[0] is not None else 0.0
+#     except Exception as e:
+#         logger.error(f"Erreur de connexion à la base de données pour la latence : {e}")
+#         return 0.0
+#     finally:
+#         cursor.close()
+#         conn.close()
+
+
+def get_average_latency() -> float:
+    """
+    Récupère la latence moyenne des traitements enregistrés dans la table `messages` de la base de données SQLite.
+    
+    Cette fonction se connecte à la base de données SQLite, exécute une requête pour calculer la moyenne des valeurs 
+    dans la colonne `temps_traitement` de la table `messages`, et retourne cette moyenne avec une précision de deux décimales.
+    
+    Returns:
+        float: La latence moyenne des traitements en secondes. Retourne 0.0 en cas d'erreur ou si aucune donnée valide n'est disponible.
+    """
+    # Connexion à la base de données SQLite
     conn = get_db_connection()
+
+    # Si la connexion échoue, on retourne 0.0
     if conn is None:
         return 0.0
+
     try:
+        # Création du curseur pour exécuter la requête
         cursor = conn.cursor()
-        cursor.execute("SELECT AVG(temps_traitement) FROM messages WHERE temps_traitement IS NOT NULL")
+
+        # Exécution de la requête SQL pour calculer la moyenne de la colonne 'temps_traitement'
+        cursor.execute(
+            "SELECT AVG(temps_traitement) FROM messages WHERE temps_traitement IS NOT NULL"
+        )
+
+        # Récupération du résultat de la requête
         result = cursor.fetchone()
+
+        # Retour de la moyenne arrondie à 2 décimales, ou 0.0 si aucun résultat
         return round(result[0], 2) if result[0] is not None else 0.0
-    except Exception as e:
+
+    except sqlite3.Error as e:
+        # En cas d'erreur, on enregistre l'erreur dans les logs et on retourne 0.0
         logger.error(f"Erreur de connexion à la base de données pour la latence : {e}")
         return 0.0
+
     finally:
+        # Fermeture du curseur et de la connexion
         cursor.close()
         conn.close()
 
+
 # Fonction pour récupérer le nombre de requêtes par jour
-def get_daily_requests():
+# def get_daily_requests():
+#     conn = get_db_connection()
+#     if conn is None:
+#         return pd.DataFrame()
+#     try:
+#         query = """
+#         SELECT
+#             DATE(timestamp) AS date,
+#             COUNT(*) AS nombre_requetes
+#         FROM
+#             messages
+#         GROUP BY
+#             date
+#         ORDER BY
+#             date;
+#         """
+#         df = pd.read_sql(query, conn)
+#         return df
+#     except Exception as e:
+#         logger.error(f"Erreur lors de la récupération des requêtes par jour : {e}")
+#         return pd.DataFrame()
+#     finally:
+#         conn.close()
+
+
+def get_daily_requests() -> pd.DataFrame:
+    """
+    Récupère les requêtes quotidiennes à partir de la table `messages` de la base de données SQLite.
+    
+    Cette fonction se connecte à la base de données SQLite, exécute une requête SQL pour compter le nombre de requêtes
+    (messages) par jour, et retourne les résultats sous forme de DataFrame pandas.
+    
+    Returns:
+        pd.DataFrame: Un DataFrame contenant les dates et le nombre de requêtes pour chaque jour. 
+                      Retourne un DataFrame vide en cas d'erreur.
+    """
+    # Connexion à la base de données SQLite
     conn = get_db_connection()
+
+    # Si la connexion échoue, retourner un DataFrame vide
     if conn is None:
         return pd.DataFrame()
+
     try:
+        # Requête SQL pour récupérer le nombre de requêtes par jour
         query = """
         SELECT
             DATE(timestamp) AS date,
@@ -77,61 +223,196 @@ def get_daily_requests():
         ORDER BY
             date;
         """
+
+        # Exécution de la requête et récupération du résultat sous forme de DataFrame
         df = pd.read_sql(query, conn)
+
+        # Retour du DataFrame contenant les résultats
         return df
-    except Exception as e:
+
+    except sqlite3.Error as e:
+        # En cas d'erreur, on enregistre l'erreur dans les logs et on retourne un DataFrame vide
         logger.error(f"Erreur lors de la récupération des requêtes par jour : {e}")
         return pd.DataFrame()
+
     finally:
+        # Fermeture de la connexion à la base de données
         conn.close()
 
 
 # Fonction pour récupérer les ingrédients depuis la base de données
-def get_ingredients():
+# def get_ingredients():
+#     conn = get_db_connection()
+#     cursor = conn.cursor()
+#     try:
+#         cursor.execute("SELECT ingredients FROM liste_courses")
+#         ingredients_list = cursor.fetchall()  # Récupère tous les résultats
+#         return ingredients_list
+#     except Exception as e:
+#         logger.error(f"Erreur lors de la récupération des requêtes par jour : {e}")
+#         return pd.DataFrame()
+#     finally:
+#         # Fermer la connexion
+#         cursor.close()
+#         conn.close()
+
+
+def get_ingredients() -> list:
+    """
+    Récupère la liste des ingrédients stockée dans la table `liste_courses` de la base de données SQLite.
+
+    Cette fonction se connecte à la base de données SQLite, exécute une requête SQL pour récupérer la colonne `ingredients`
+    de la table `liste_courses`, et retourne les résultats sous forme de liste.
+
+    Returns:
+        list: Une liste contenant les ingrédients récupérés de la base de données. 
+              Retourne une liste vide en cas d'erreur.
+    """
+    # Connexion à la base de données SQLite
     conn = get_db_connection()
+
+    # Si la connexion échoue, retourner une liste vide
+    if conn is None:
+        return []
+
     cursor = conn.cursor()
+
     try:
+        # Requête SQL pour récupérer la colonne 'ingredients' de la table 'liste_courses'
         cursor.execute("SELECT ingredients FROM liste_courses")
-        ingredients_list = cursor.fetchall()  # Récupère tous les résultats
-        return ingredients_list
-    except Exception as e:
-        logger.error(f"Erreur lors de la récupération des requêtes par jour : {e}")
-        return pd.DataFrame()
+
+        # Récupère tous les résultats de la requête
+        ingredients_list = cursor.fetchall()
+
+        # Retourne la liste des ingrédients (sous forme de liste de tuples)
+        return [ingredient[0] for ingredient in ingredients_list]
+
+    except sqlite3.Error as e:
+        # En cas d'erreur, on enregistre l'erreur dans les logs et on retourne une liste vide
+        logger.error(f"Erreur lors de la récupération des ingrédients : {e}")
+        return []
+
     finally:
-        # Fermer la connexion
+        # Fermeture du curseur et de la connexion à la base de données
         cursor.close()
         conn.close()
 
+
 # Fonction pour récupérer le coût total des requêtes
-def get_total_cost():
+# def get_total_cost():
+#     conn = get_db_connection()
+#     if conn is None:
+#         return 0.0
+#     try:
+#         cursor = conn.cursor()
+#         cursor.execute("SELECT SUM(total_cout) FROM messages WHERE total_cout IS NOT NULL")
+#         result = cursor.fetchone()
+#         return round(result[0], 2) if result[0] is not None else 0.0
+#     except Exception as e:
+#         logger.error(f"Erreur lors de la récupération du coût total : {e}")
+#         return 0.0
+#     finally:
+#         cursor.close()
+#         conn.close()
+
+
+def get_total_cost() -> float:
+    """
+    Récupère le coût total des messages dans la table `messages` de la base de données SQLite.
+
+    Cette fonction se connecte à la base de données SQLite, exécute une requête SQL pour récupérer la somme des valeurs 
+    présentes dans la colonne `total_cout` de la table `messages`, et retourne le total arrondi à 2 décimales.
+
+    Returns:
+        float: Le coût total des messages. Retourne 0.0 si aucune donnée n'est disponible ou en cas d'erreur.
+    """
+    # Connexion à la base de données SQLite
     conn = get_db_connection()
+
+    # Si la connexion échoue, retourner 0.0
     if conn is None:
         return 0.0
+
+    cursor = conn.cursor()
+
     try:
-        cursor = conn.cursor()
-        cursor.execute("SELECT SUM(total_cout) FROM messages WHERE total_cout IS NOT NULL")
+        # Requête SQL pour récupérer la somme de la colonne 'total_cout' de la table 'messages'
+        cursor.execute(
+            "SELECT SUM(total_cout) FROM messages WHERE total_cout IS NOT NULL"
+        )
+
+        # Récupère le résultat de la requête
         result = cursor.fetchone()
+
+        # Retourne la somme arrondie à 2 décimales si un résultat est trouvé, sinon retourne 0.0
         return round(result[0], 2) if result[0] is not None else 0.0
-    except Exception as e:
+
+    except sqlite3.Error as e:
+        # En cas d'erreur, on log l'erreur et on retourne 0.0
         logger.error(f"Erreur lors de la récupération du coût total : {e}")
         return 0.0
+
     finally:
+        # Fermeture du curseur et de la connexion à la base de données
         cursor.close()
         conn.close()
 
+
 # Fonction pour récupérer l'impact écologique estimé
-def get_total_impact():
+# def get_total_impact():
+#     conn = get_db_connection()
+#     if conn is None:
+#         return 0.0
+#     try:
+#         cursor = conn.cursor()
+#         cursor.execute("SELECT SUM(impact_eco) FROM messages WHERE impact_eco IS NOT NULL")
+#         result = cursor.fetchone()
+#         return round(result[0], 2) if result[0] is not None else 0.0
+#     except Exception as e:
+#         logger.error(f"Erreur lors de la récupération de l'impact écologique : {e}")
+#         return 0.0
+#     finally:
+#         cursor.close()
+#         conn.close()
+
+
+def get_total_impact() -> float:
+    """
+    Récupère l'impact écologique total des messages dans la table `messages` de la base de données SQLite.
+
+    Cette fonction se connecte à la base de données SQLite, exécute une requête SQL pour récupérer la somme des valeurs 
+    présentes dans la colonne `impact_eco` de la table `messages`, et retourne le total arrondi à 2 décimales.
+
+    Returns:
+        float: L'impact écologique total des messages. Retourne 0.0 si aucune donnée n'est disponible ou en cas d'erreur.
+    """
+    # Connexion à la base de données SQLite
     conn = get_db_connection()
+
+    # Si la connexion échoue, retourner 0.0
     if conn is None:
         return 0.0
+
+    cursor = conn.cursor()
+
     try:
-        cursor = conn.cursor()
-        cursor.execute("SELECT SUM(impact_eco) FROM messages WHERE impact_eco IS NOT NULL")
+        # Requête SQL pour récupérer la somme de la colonne 'impact_eco' de la table 'messages'
+        cursor.execute(
+            "SELECT SUM(impact_eco) FROM messages WHERE impact_eco IS NOT NULL"
+        )
+
+        # Récupère le résultat de la requête
         result = cursor.fetchone()
+
+        # Retourne la somme arrondie à 2 décimales si un résultat est trouvé, sinon retourne 0.0
         return round(result[0], 2) if result[0] is not None else 0.0
-    except Exception as e:
+
+    except sqlite3.Error as e:
+        # En cas d'erreur, on log l'erreur et on retourne 0.0
         logger.error(f"Erreur lors de la récupération de l'impact écologique : {e}")
         return 0.0
+
     finally:
+        # Fermeture du curseur et de la connexion à la base de données
         cursor.close()
         conn.close()

server/db/dbmanager.py

@@ -1,5 +1,6 @@
 import streamlit as st
 import psycopg2
+import sqlite3
 from psycopg2 import extras
 from datetime import datetime
 import logging
@@ -7,32 +8,34 @@ import json
 import pandas as pd
 from typing import List, Dict, Tuple
 import os
-import sys 
+import sys
 
 # Configuration du logging
 logging.basicConfig(level=logging.INFO, handlers=[logging.StreamHandler()])
 logger = logging.getLogger(__name__)
 
-sys.stdout.reconfigure(encoding='utf-8')
+sys.stdout.reconfigure(encoding="utf-8")
 
 # Configuration de la base de données
 db_config = {
     "database": st.secrets["DB_NAME"],
-    "user": st.secrets["DB_USER"],
-    "password": st.secrets["DB_PASSWORD"],
-    "host": st.secrets["DB_HOST"],
-    "port": st.secrets["DB_PORT"]
+    # "user": st.secrets["DB_USER"],
+    # "password": st.secrets["DB_PASSWORD"],
+    # "host": st.secrets["DB_HOST"],
+    # "port": st.secrets["DB_PORT"]
 }
 
 ######################### CLASSES #########################
 
+
 class DBManager:
-    def __init__(self, db_config: Dict, schema_file: str):
+    def __init__(self, db_config: Dict, schema_file: str) -> None:
         """
         Initialise la connexion à la base PostgreSQL et charge le schéma.
-        
-        :param db_config: Dictionnaire avec les informations de connexion (host, database, user, password).
-        :param schema_file: Chemin vers le fichier JSON contenant le schéma de la base.
+
+        Args:
+            db_config (Dict) : dictionnaire avec les informations de connexion (host, database, user, password).
+            schema_file (str) : chemin vers le fichier JSON contenant le schéma de la base.
         """
 
         self.db_config = db_config
@@ -42,134 +45,293 @@ class DBManager:
         self._load_schema()
         self._connect_to_database()
         self._create_database()
-        self.cursor.execute("SET NAMES 'UTF8'")
+        # self.cursor.execute("SET NAMES 'UTF8'")
 
-        
-
-    def _load_schema(self):
-        """Charge le schéma de base de données depuis un fichier JSON."""
+    def _load_schema(self) -> None:
+        """
+        Charge le schéma de base de données depuis un fichier JSON.
+        """
         if not os.path.exists(self.schema_file):
             raise FileNotFoundError(f"Fichier non trouvé : {self.schema_file}")
-        
+
         with open(self.schema_file, "r", encoding="utf-8") as file:
             self.schema = json.load(file)
 
-    def _connect_to_database(self):
-        """Établit une connexion avec la base PostgreSQL."""
+    # def _connect_to_database(self):
+    #     """Établit une connexion avec la base PostgreSQL."""
+    #     try:
+    #         self.connection = psycopg2.connect(**self.db_config, cursor_factory=extras.DictCursor)
+    #         self.cursor = self.connection.cursor()
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
+
+    def _connect_to_database(self) -> None:
+        """
+        Établit une connexion avec la base SQLite.
+        """
         try:
-            self.connection = psycopg2.connect(**self.db_config, cursor_factory=extras.DictCursor)
+            # Connexion à la base de données SQLite
+            self.connection = sqlite3.connect(
+                self.db_config["database"], check_same_thread=False
+            )
+            self.connection.row_factory = (
+                sqlite3.Row
+            )  # Pour des résultats sous forme de dictionnaire
             self.cursor = self.connection.cursor()
-        except psycopg2.Error as err:
+        except sqlite3.Error as err:
             logger.error(f"Erreur de connexion : {err}")
             return
 
-    def _create_database(self):
-        """Crée les tables définies dans le schéma JSON."""
-        for table_name, table_info in self.schema['tables'].items():
-            create_table_query = self._generate_create_table_query(table_name, table_info['columns'])
+    # def _create_database(self):
+    #     """Crée les tables définies dans le schéma JSON."""
+    #     for table_name, table_info in self.schema['tables'].items():
+    #         create_table_query = self._generate_create_table_query(table_name, table_info['columns'])
+    #         try:
+    #             self.cursor.execute(create_table_query)
+    #         except psycopg2.Error as err:
+    #             logger.error(f"Erreur de connexion : {err}")
+    #             return
+    #         finally:
+    #             self.connection.commit()
+
+    import sqlite3
+
+    def _create_database(self) -> None:
+        """
+        Crée les tables définies dans le schéma JSON.
+        """
+        for table_name, table_info in self.schema["tables"].items():
+            create_table_query = self._generate_create_table_query(
+                table_name, table_info["columns"]
+            )
             try:
                 self.cursor.execute(create_table_query)
-            except psycopg2.Error as err:
-                logger.error(f"Erreur de connexion : {err}")
+            except sqlite3.Error as err:
+                logger.error(
+                    f"Erreur lors de la création de la table {table_name}: {err}"
+                )
                 return
             finally:
                 self.connection.commit()
 
+    # def _generate_create_table_query(self, table_name: str, columns: List[Dict]) -> str:
+    #     """Génère une requête SQL pour créer une table en fonction du schéma."""
+    #     column_definitions = []
+    #     for column in columns:
+    #         column_definition = f"{column['name']} {column['type']}"
+    #         if 'constraints' in column and column['constraints']:
+    #             column_definition += " " + " ".join(column['constraints'])
+    #         column_definitions.append(column_definition)
+    #     columns_str = ", ".join(column_definitions)
+    #     return f"CREATE TABLE IF NOT EXISTS {table_name} ({columns_str});"
+
     def _generate_create_table_query(self, table_name: str, columns: List[Dict]) -> str:
-        """Génère une requête SQL pour créer une table en fonction du schéma."""
+        """
+        Génère une requête SQL pour créer une table en fonction du schéma.
+
+        Args:
+            table_name (str): nom de la table.
+            columns (List[Dict]): colonnes de la table à créer.
+        
+        Returns:
+            str : la requête SQL CREATE TABLE paramétrée.
+
+        """
         column_definitions = []
         for column in columns:
             column_definition = f"{column['name']} {column['type']}"
-            if 'constraints' in column and column['constraints']:
-                column_definition += " " + " ".join(column['constraints'])
+
+            # Conversion quand le type n'est pas compatible avec SQLite (ex. : SERIAL -> INTEGER PRIMARY KEY AUTOINCREMENT)
+            if column["type"] == "SERIAL":
+                column_definition = (
+                    f"{column['name']} INTEGER PRIMARY KEY AUTOINCREMENT"
+                )
+
+            if "constraints" in column and column["constraints"]:
+                column_definition += " " + " ".join(column["constraints"])
+
             column_definitions.append(column_definition)
+
         columns_str = ", ".join(column_definitions)
         return f"CREATE TABLE IF NOT EXISTS {table_name} ({columns_str});"
 
-    def insert_data_from_dict(self, table_name: str, data: List[Dict], id_column: str) -> List[int]:
-        """Insère des données dans une table à partir d'une liste de dictionnaires et retourne les IDs insérés.
-        
-        table_name : str : nom de la table
-        data : List[Dict] : données à insérer
-        id_column : str : nom de la colonne d'ID à retourner
+    # def insert_data_from_dict(self, table_name: str, data: List[Dict], id_column: str) -> List[int]:
+    #     """Insère des données dans une table à partir d'une liste de dictionnaires et retourne les IDs insérés.
+
+    #     table_name : str : nom de la table
+    #     data : List[Dict] : données à insérer
+    #     id_column : str : nom de la colonne d'ID à retourner
+    #     """
+    #     columns = ", ".join(data[0].keys())
+    #     placeholders = ", ".join(['%s' for _ in data[0].keys()])
+
+    #     # Requête pour insérer les données et retourner l'ID dynamique
+    #     query = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders}) RETURNING {id_column}"
+
+    #     ids = []
+    #     try:
+    #         for row in data:
+    #             self.cursor.execute(query, tuple(row.values()))
+    #             inserted_id = self.cursor.fetchone()[0]
+    #             ids.append(inserted_id)
+    #         return ids
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
+    #     finally:
+    #         self.connection.commit()
+
+    def insert_data_from_dict(self, table_name: str, data: List[Dict]) -> List[int]:
         """
-        columns = ", ".join(data[0].keys())
-        placeholders = ", ".join(['%s' for _ in data[0].keys()])
+        Insère des données dans une table à partir d'une liste de dictionnaires et retourne les IDs insérés.
         
-        # Requête pour insérer les données et retourner l'ID dynamique
-        query = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders}) RETURNING {id_column}"  
+        Args:
+            table_name (str): nom de la table.
+            data (List[Dict]): données à insérer.
         
-        ids = [] 
+        Returns:
+            List[int]: liste des ID des données insérées.
+        """
+        columns = ", ".join(data[0].keys())
+        placeholders = ", ".join(
+            ["?" for _ in data[0].keys()]
+        )  # SQLite utilise '?' pour les placeholders
+
+        # Requête pour insérer les données
+        query = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders})"
+
+        ids = []
         try:
             for row in data:
                 self.cursor.execute(query, tuple(row.values()))
-                inserted_id = self.cursor.fetchone()[0]  
+                inserted_id = (
+                    self.cursor.lastrowid
+                )  # Récupère l'ID du dernier enregistrement inséré
                 ids.append(inserted_id)
             return ids
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
+        except sqlite3.Error as err:
+            logger.error(
+                f"Erreur lors de l'insertion des données dans {table_name}: {err}"
+            )
             return
         finally:
             self.connection.commit()
 
-    def insert_data_from_dict(self, table_name: str, data: List[Dict], id_column: str) -> List[int]:
-        """Insère des données dans une table à partir d'une liste de dictionnaires et retourne les IDs insérés.
-        
-        table_name : str : nom de la table
-        data : List[Dict] : données à insérer
-        id_column : str : nom de la colonne d'ID à retourner
-        """
-        columns = ", ".join(data[0].keys())
-        placeholders = ", ".join(['%s' for _ in data[0].keys()])
-        
-        # Requête pour insérer les données et retourner l'ID dynamique
-        query = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders}) RETURNING {id_column}"  
-        
-        ids = []  # Liste pour stocker les IDs retournés
-        for row in data:
-            self.cursor.execute(query, tuple(row.values()))
-            inserted_id = self.cursor.fetchone()[0]  # Récupère le premier (et unique) élément de la ligne retournée
-            ids.append(inserted_id)
-        
-        self.connection.commit()
-        return ids
-
+    # def insert_data_from_csv(self, table_name: str, csv_file: str) -> None:
+    #     """Insère des données dans une table à partir d'un fichier CSV."""
+    #     df = pd.read_csv(csv_file)
+    #     columns = df.columns.tolist()
+    #     placeholders = ", ".join(['%s' for _ in columns])
+    #     query = f"INSERT INTO {table_name} ({', '.join(columns)}) VALUES ({placeholders})"
 
+    #     try:
+    #         for row in df.itertuples(index=False, name=None):
+    #             self.cursor.execute(query, row)
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
+    #     finally:
+    #         self.connection.commit()
 
     def insert_data_from_csv(self, table_name: str, csv_file: str) -> None:
-        """Insère des données dans une table à partir d'un fichier CSV."""
+        """
+        Insère des données dans une table à partir d'un fichier CSV.
+        
+        Args:
+            table_name (str): nom de la table dans laquelle insérer des données.
+            csv_file (str): lien du fichier csv contenant les données.
+        """
         df = pd.read_csv(csv_file)
         columns = df.columns.tolist()
-        placeholders = ", ".join(['%s' for _ in columns])
-        query = f"INSERT INTO {table_name} ({', '.join(columns)}) VALUES ({placeholders})"
-        
+        placeholders = ", ".join(
+            ["?" for _ in columns]
+        )  # Utilisation de '?' pour SQLite
+        query = (
+            f"INSERT INTO {table_name} ({', '.join(columns)}) VALUES ({placeholders})"
+        )
+
         try:
             for row in df.itertuples(index=False, name=None):
-                self.cursor.execute(query, row)
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
-            return
+                self.cursor.execute(
+                    query, row
+                )  # Exécution de la requête avec les valeurs du CSV
+        except sqlite3.Error as err:
+            logger.error(
+                f"Erreur lors de l'insertion des données depuis {csv_file} : {err}"
+            )
         finally:
             self.connection.commit()
 
+    # def fetch_all(self, table_name: str) -> List[Tuple]:
+    #     """
+    #     Récupère toutes les données d'une table.
+
+    #     Args:
+    #         table_name (str): nom de la table de laquelle récupérer des données.
+
+    #     Returns:
+    #         List[Tuple]: liste des enregistrements récupérés à partir de la table.
+    #     """
+    #     try:
+    #         self.cursor.execute(f"SELECT * FROM {table_name}")
+    #         return self.cursor.fetchall()
+    #     except sqlite3.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
+
     def fetch_all(self, table_name: str) -> List[Tuple]:
-        """Récupère toutes les données d'une table."""
+        """
+        Récupère toutes les données d'une table.
+        
+        Args:
+            table_name (str): nom de la table de laquelle récupérer des données.
+
+        Returns:
+            List[Tuple]: liste des enregistrements récupérés à partir de la table.
+        """
         try:
             self.cursor.execute(f"SELECT * FROM {table_name}")
             return self.cursor.fetchall()
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
-            return
-    
-    
-    def execute_safe(self, query: str, params: Tuple = (), fetch: bool = False):
+        except sqlite3.Error as err:
+            logger.error(
+                f"Erreur lors de la récupération des données de la table {table_name} : {err}"
+            )
+            return []  # Retourne une liste vide en cas d'erreur
+
+    # def execute_safe(self, query: str, params: Tuple = (), fetch: bool = False):
+    #     """
+    #     Exécute une requête SQL avec gestion centralisée des erreurs.
+
+    #     :param query: Requête SQL à exécuter.
+    #     :param params: Paramètres de la requête.
+    #     :param fetch: Indique si les résultats doivent être récupérés.
+    #     :return: Résultats de la requête (si fetch est True), sinon None.
+    #     """
+    #     try:
+    #         self.cursor.execute(query, params)
+    #         if fetch:
+    #             return self.cursor.fetchall()  # Retourner les résultats si demandé
+    #         else:
+    #             self.connection.commit()  # Valider les modifications
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         self.connection.rollback()  # Annuler la transaction en cas d'erreur
+    #         raise RuntimeError(f"Erreur SQL : {err} | Query : {query} | Params : {params}")
+
+    def execute_safe(
+        self, query: str, params: Tuple = (), fetch: bool = False
+    ) -> List[Tuple]:
         """
         Exécute une requête SQL avec gestion centralisée des erreurs.
         
-        :param query: Requête SQL à exécuter.
-        :param params: Paramètres de la requête.
-        :param fetch: Indique si les résultats doivent être récupérés.
-        :return: Résultats de la requête (si fetch est True), sinon None.
+        Args:
+            query (str): requête SQL à exécuter.
+            params (Tuple): paramètres de la requête.
+            fetch (bool): indique si les résultats doivent être récupérés.
+        
+        Returns:
+            List[Tuple]: résultats de la requête (si fetch est True), sinon None.
         """
         try:
             self.cursor.execute(query, params)
@@ -177,300 +339,715 @@ class DBManager:
                 return self.cursor.fetchall()  # Retourner les résultats si demandé
             else:
                 self.connection.commit()  # Valider les modifications
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
+        except sqlite3.Error as err:
+            logger.error(f"Erreur lors de l'exécution de la requête : {err}")
             self.connection.rollback()  # Annuler la transaction en cas d'erreur
-            raise RuntimeError(f"Erreur SQL : {err} | Query : {query} | Params : {params}")
+            raise RuntimeError(
+                f"Erreur SQL : {err} | Query : {query} | Params : {params}"
+            )
 
+    # def fetch_by_condition(self, table_name: str, condition: str, params: Tuple = ()) -> List[Tuple]:
+    #     """Récupère les données d'une table avec une condition."""
+    #     query = f"SELECT * FROM {table_name} WHERE {condition}"
+    #     try:
+    #         self.cursor.execute(query, params)
+    #         return self.execute_safe(query, params, fetch=True)
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
 
-    def fetch_by_condition(self, table_name: str, condition: str, params: Tuple = ()) -> List[Tuple]:
-        """Récupère les données d'une table avec une condition."""
+    def fetch_by_condition(
+        self, table_name: str, condition: str, params: Tuple = ()
+    ) -> List[Tuple]:
+        """
+        Récupère les données d'une table avec une condition.
+        
+        Args:
+            table_name (str): nom de la table de laquelle récupérer des données.
+            condition (str): condition qui sera inclue dans la clause WHERE pour filtrage.
+            params (Tuple): paramètres de la requête.
+
+        Returns:
+            List[Tuple]: résultats de la requête (si fetch est True), sinon None (via la fonction execute_safe).
+        """
         query = f"SELECT * FROM {table_name} WHERE {condition}"
         try:
-            self.cursor.execute(query, params)
+            # Utilise execute_safe pour exécuter la requête et récupérer les résultats
             return self.execute_safe(query, params, fetch=True)
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
-            return
-   
+        except sqlite3.Error as err:
+            logger.error(
+                f"Erreur lors de la récupération des données de {table_name} avec condition '{condition}': {err}"
+            )
+            return []
+
+    # def update_data(self, table_name: str, set_clause: str, condition: str, params: Tuple) -> None:
+    #     """Met à jour des données dans une table."""
+    #     query = f"UPDATE {table_name} SET {set_clause} WHERE {condition}"
+    #     try:
+    #         self.cursor.execute(query, params)
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
+    #     finally:
+    #         self.connection.commit()
 
-    def update_data(self, table_name: str, set_clause: str, condition: str, params: Tuple) -> None:
-        """Met à jour des données dans une table."""
+    def update_data(
+        self, table_name: str, set_clause: str, condition: str, params: Tuple
+    ) -> None:
+        """
+        Met à jour des données dans une table.
+        
+        Args:
+            table_name (str): nom de la table dont les données vont être mises à jour.
+            set_clause (str): information qui sera inclue dans la clause SET pour la mise à jour.
+            condition (str): condition qui sera inclue dans la clause WHERE pour filtrage.
+            params (Tuple): paramètres de la requête.
+        """
         query = f"UPDATE {table_name} SET {set_clause} WHERE {condition}"
         try:
             self.cursor.execute(query, params)
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
-            return
+        except sqlite3.Error as err:
+            logger.error(
+                f"Erreur lors de la mise à jour des données dans {table_name} : {err}"
+            )
         finally:
-            self.connection.commit()
+            self.connection.commit()  # Valider les modifications
+
+    # def delete_data(self, table_name: str, condition: str, params: Tuple) -> None:
+    #     """Supprime des données d'une table selon une condition."""
+    #     query = f"DELETE FROM {table_name} WHERE {condition}"
+    #     try:
+    #         self.cursor.execute(query, params)
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
+    #     finally:
+    #         self.connection.commit()
 
     def delete_data(self, table_name: str, condition: str, params: Tuple) -> None:
-        """Supprime des données d'une table selon une condition."""
+        """
+        Supprime des données d'une table selon une condition.
+        
+        Args:
+            table_name (str): nom de la table dont les données vont être suprimées.
+            condition (str): condition qui sera inclue dans la clause WHERE pour filtrage.
+            params (Tuple): paramètres de la requête.
+        """
         query = f"DELETE FROM {table_name} WHERE {condition}"
         try:
             self.cursor.execute(query, params)
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
-            return
+        except sqlite3.Error as err:
+            logger.error(
+                f"Erreur lors de la suppression des données dans {table_name} : {err}"
+            )
         finally:
-            self.connection.commit()
+            self.connection.commit()  # Valider les modifications
+
+    # def close_connection(self) -> None:
+    #     """Ferme la connexion à la base de données."""
+    #     if self.connection:
+    #         self.cursor.close()
+    #         self.connection.close()
 
     def close_connection(self) -> None:
-        """Ferme la connexion à la base de données."""
+        """
+        Ferme la connexion à la base de données.
+        """
         if self.connection:
-            self.cursor.close()
-            self.connection.close()
+            try:
+                self.cursor.close()  # Fermer le curseur
+                self.connection.close()  # Fermer la connexion
+            except sqlite3.Error as err:
+                logger.error(f"Erreur lors de la fermeture de la connexion : {err}")
+
+    # def create_index(self, table_name: str, column_name: str) -> None:
+    #     """Crée un index sur une colonne spécifique pour améliorer les performances de recherche."""
+    #     query = f"CREATE INDEX IF NOT EXISTS idx_{table_name}_{column_name} ON {table_name} ({column_name})"
+    #     try:
+    #         self.cursor.execute(query)
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
+    #     finally:
+    #         self.connection.commit()
 
     def create_index(self, table_name: str, column_name: str) -> None:
-        """Crée un index sur une colonne spécifique pour améliorer les performances de recherche."""
+        """
+        Crée un index sur une colonne spécifique pour améliorer les performances de recherche.
+        """
         query = f"CREATE INDEX IF NOT EXISTS idx_{table_name}_{column_name} ON {table_name} ({column_name})"
         try:
             self.cursor.execute(query)
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
-            return
+        except sqlite3.Error as err:
+            logger.error(
+                f"Erreur lors de la création de l'index sur {table_name} ({column_name}) : {err}"
+            )
         finally:
-            self.connection.commit()
+            self.connection.commit()  # Valider les modifications
+
+    # def select(self, query: str, params: Tuple = ()) -> List[Tuple]:
+    #     """Exécute une requête SELECT personnalisée et retourne les résultats."""
+    #     try:
+    #         self.cursor.execute(query, params)
+    #         return self.cursor.fetchall()
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
 
     def select(self, query: str, params: Tuple = ()) -> List[Tuple]:
-        """Exécute une requête SELECT personnalisée et retourne les résultats."""
+        """
+        Exécute une requête SELECT personnalisée et retourne les résultats.
+        
+        Args:
+            query (str): requête SELECT.
+            params (Tuple): paramètres de la requête.
+
+        Returns:
+            List[Tuple]: liste des enregistrements récupérés.
+        """
         try:
             self.cursor.execute(query, params)
             return self.cursor.fetchall()
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
-            return
-    
-    def query(self, query, params=None):
+        except sqlite3.Error as err:
+            logger.error(f"Erreur lors de l'exécution de la requête SELECT : {err}")
+            return []
+
+    # def query(self, query, params=None):
+    #     """
+    #     Exécute une requête SQL, en utilisant les paramètres fournis,
+    #     et retourne les résultats si nécessaire.
+    #     """
+    #     try:
+    #         self.cursor.execute(query, params)
+    #     except psycopg2.Error as err:
+    #         logger.error(f"Erreur de connexion : {err}")
+    #         return
+    #     finally:
+    #         # Si la requête est un SELECT, récupérer les résultats
+    #         if query.strip().upper().startswith("SELECT"):
+    #             return self.cursor.fetchall()
+    #         else: # Si ce n'est pas un SELECT, ne rien retourner (utile pour INSERT/UPDATE)
+    #             self.connection.commit()
+    #             return None
+
+    def query(self, query: str, params: Tuple = None) -> List[Tuple]:
         """
-        Exécute une requête SQL, en utilisant les paramètres fournis, 
-        et retourne les résultats si nécessaire.
+        Exécute une requête SQL, en utilisant les paramètres fournis, et retourne les résultats si nécessaire.
+
+        Args:
+            query (str): reqête SQL.
+            params (Tuple): paramètres de la requête.
+
+        Returns:
+            List[Tuple]: list des enregistrements récupérés s'il s'agit d'une requête SELECT, None sinon.
         """
         try:
-            self.cursor.execute(query, params)
-        except psycopg2.Error as err:
-            logger.error(f"Erreur de connexion : {err}")
+            if params is None:
+                self.cursor.execute(query)
+            else:
+                self.cursor.execute(query, params)
+        except sqlite3.Error as err:
+            logger.error(f"Erreur lors de l'exécution de la requête : {err}")
             return
         finally:
             # Si la requête est un SELECT, récupérer les résultats
             if query.strip().upper().startswith("SELECT"):
                 return self.cursor.fetchall()
-            else: # Si ce n'est pas un SELECT, ne rien retourner (utile pour INSERT/UPDATE)
+            else:  # Si ce n'est pas un SELECT, ne rien retourner (utile pour INSERT/UPDATE)
                 self.connection.commit()
-                return None  
-        
+                return None
 
 
-    
-
 ######################### FONCTIONS #########################
 
 # Mettre DBManager en cache
 @st.cache_resource
 def get_db_manager():
-    return DBManager(db_config, os.path.join("server","db","schema.json"))
+    return DBManager(db_config, os.path.join("server", "db", "schema.json"))
+
 
+# def save_message(db_manager, id_conversation: int, role: str, content: str,temps_traitement, total_cout, impact_eco) -> None:
+#     """
+#     Sauvegarde un message dans la base de données, en associant l'utilisateur à la conversation.
 
-def save_message(db_manager, id_conversation: int, role: str, content: str,temps_traitement, total_cout, impact_eco) -> None:
+#     :param db_manager: Instance de DBManager.
+#     :param id_conversation: ID de la conversation associée.
+#     :param role: Rôle de l'intervenant (ex. 'user' ou 'assistant').
+#     :param content: Contenu du message.
+#     """
+#     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+#     data = [{
+#         "id_conversation": id_conversation,
+#         "role": role,
+#         "content": content,
+#         "timestamp": timestamp,
+#         "temps_traitement":temps_traitement,
+#         "total_cout": total_cout,
+#         "impact_eco": impact_eco
+#     }]
+#     try:
+#         db_manager.insert_data_from_dict("messages", data, id_column="id_message")
+#     except psycopg2.Error as err:
+#         logger.error(f"Erreur de connexion: {err}")
+#         return
+
+
+def save_message(
+    db_manager,
+    id_conversation: int,
+    role: str,
+    content: str,
+    temps_traitement: float,
+    total_cout: float,
+    impact_eco: float,
+) -> None:
     """
     Sauvegarde un message dans la base de données, en associant l'utilisateur à la conversation.
     
-    :param db_manager: Instance de DBManager.
-    :param id_conversation: ID de la conversation associée.
-    :param role: Rôle de l'intervenant (ex. 'user' ou 'assistant').
-    :param content: Contenu du message.
+    Args:
+        db_manager: instance de DBManager.
+        id_conversation (int): ID de la conversation associée.
+        role (str): rôle de l'intervenant (ex. 'user' ou 'assistant').
+        content (str): contenu du message.
+        temps_traitement (float): temps de traitement.
+        total_cout (float): coût total associé au message.
+        impact_eco (float): impact économique du message.
     """
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    data = [{
-        "id_conversation": id_conversation,
-        "role": role,
-        "content": content,
-        "timestamp": timestamp,
-        "temps_traitement":temps_traitement,
-        "total_cout": total_cout,
-        "impact_eco": impact_eco
-    }]
+    data = [
+        {
+            "id_conversation": id_conversation,
+            "role": role,
+            "content": content,
+            "timestamp": timestamp,
+            "temps_traitement": temps_traitement,
+            "total_cout": total_cout,
+            "impact_eco": impact_eco,
+        }
+    ]
+
     try:
-        db_manager.insert_data_from_dict("messages", data, id_column="id_message")
-    except psycopg2.Error as err:
-        logger.error(f"Erreur de connexion: {err}")
-        return    
+        # Insertion des données dans la table "messages" en utilisant la méthode d'insertion adaptée
+        db_manager.insert_data_from_dict("messages", data)
+    except sqlite3.Error as err:  # Utilisation de sqlite3.Error pour gérer les exceptions SQLite
+        logger.error(f"Erreur lors de la sauvegarde du message : {err}")
+        return
+
+
+# def create_conversation(db_manager, title: str, id_utilisateur: int) -> int:
+#     """
+#     Crée une nouvelle conversation dans la base de données, en associant l'utilisateur à la conversation.
+
+#     :param db_manager: Instance de DBManager.
+#     :param title: Titre de la conversation.
+#     :param id_utilisateur: ID de l'utilisateur associé.
+#     :return: ID de la conversation nouvellement créée.
+#     """
+#     created_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+#     data = [{
+#         "created_at": created_at,
+#         "title": title,
+#         "id_utilisateur": id_utilisateur,
+#     }]
+#     try:
+#         result = db_manager.insert_data_from_dict("conversations", data, id_column="id_conversation")
+#         return result[0]
+#     except psycopg2.Error as err:
+#         logger.error(f"Erreur de connexion : {err}")
+#         return
+
 
 def create_conversation(db_manager, title: str, id_utilisateur: int) -> int:
     """
     Crée une nouvelle conversation dans la base de données, en associant l'utilisateur à la conversation.
     
-    :param db_manager: Instance de DBManager.
-    :param title: Titre de la conversation.
-    :param id_utilisateur: ID de l'utilisateur associé.
-    :return: ID de la conversation nouvellement créée.
+    Args:
+        db_manager: instance de DBManager.
+        title (str): titre de la conversation.
+        id_utilisateur (int): ID de l'utilisateur associé.
+
+    Returns:
+        int: ID de la conversation nouvellement créée.
+        
     """
     created_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    data = [{
-        "created_at": created_at,
-        "title": title,
-        "id_utilisateur": id_utilisateur,
-    }]
+    data = [
+        {"created_at": created_at, "title": title, "id_utilisateur": id_utilisateur,}
+    ]
+
     try:
-        result = db_manager.insert_data_from_dict("conversations", data, id_column="id_conversation")
-        return result[0]
-    except psycopg2.Error as err:
-        logger.error(f"Erreur de connexion : {err}")
-        return
+        result = db_manager.insert_data_from_dict("conversations", data)
+        return result[0]  # Retourne l'ID de la conversation nouvellement créée
+    except sqlite3.Error as err:  # Gestion des erreurs avec sqlite3
+        logger.error(f"Erreur lors de la création de la conversation : {err}")
+        return None
+
+
+# def load_messages(db_manager, id_conversation: int) -> List[Dict]:
+#     """
+#     Charge les messages associés à une conversation.
+
+#     :param db_manager: Instance de DBManager.
+#     :param id_conversation: ID de la conversation.
+#     :return: Liste des messages sous forme de dictionnaires.
+#     """
+#     query = """
+#         SELECT *
+#         FROM messages
+#         WHERE id_conversation = %s
+#         ORDER BY timestamp ASC
+#     """
+#     try:
+#         result = db_manager.query(query, (id_conversation,))
+#         return [{"role": row["role"], "content": row["content"], "timestamp":row["timestamp"], "temps_traitement":row["temps_traitement"]} for row in result]
+#     except psycopg2.Error as err:
+#         logger.error(f"Erreur de connexion : {err}")
+#         return
+
 
 def load_messages(db_manager, id_conversation: int) -> List[Dict]:
     """
     Charge les messages associés à une conversation.
     
-    :param db_manager: Instance de DBManager.
-    :param id_conversation: ID de la conversation.
-    :return: Liste des messages sous forme de dictionnaires.
+    Args:
+        db_manager: instance de DBManager.
+        id_conversation (int): ID de la conversation.
+    Returns:
+        List[Dict]: liste des messages sous forme de dictionnaires.
     """
     query = """
-        SELECT *
+        SELECT role, content, timestamp, temps_traitement
         FROM messages 
-        WHERE id_conversation = %s 
+        WHERE id_conversation = ? 
         ORDER BY timestamp ASC
     """
     try:
         result = db_manager.query(query, (id_conversation,))
-        return [{"role": row["role"], "content": row["content"], "timestamp":row["timestamp"], "temps_traitement":row["temps_traitement"]} for row in result]
-    except psycopg2.Error as err:
-        logger.error(f"Erreur de connexion : {err}")
-        return
+        # Résultats sous forme de dictionnaires, si la fonction query retourne des tuples ou dictionnaires
+        return [
+            {
+                "role": row["role"],
+                "content": row["content"],
+                "timestamp": row["timestamp"],
+                "temps_traitement": row["temps_traitement"],
+            }
+            for row in result
+        ]
+    except sqlite3.Error as err:  # Utilisation de sqlite3.Error pour capturer les erreurs SQLite
+        logger.error(f"Erreur lors du chargement des messages : {err}")
+        return []
+
+
+# def load_conversations(db_manager, id_utilisateur: int) -> List[Dict]:
+#     """
+#     Charge toutes les conversations enregistrées pour un utilisateur donné.
+
+#     :param db_manager: Instance de DBManager.
+#     :param id_utilisateur: ID de l'utilisateur.
+#     :return: Liste des conversations.
+#     """
+#     query = """
+#         SELECT * FROM conversations
+#         WHERE id_utilisateur = %s
+#         ORDER BY created_at DESC
+#     """
+#     try:
+#         result = db_manager.query(query, (id_utilisateur,))
+
+
+#         return [
+#             {"id_conversation": row["id_conversation"], "created_at": row["created_at"], "title": row["title"]} for row in result
+#         ]
+#     except psycopg2.Error as err:
+#         logger.error(f"Erreur de connexion : {err}")
+#         return
+
 
 def load_conversations(db_manager, id_utilisateur: int) -> List[Dict]:
     """
     Charge toutes les conversations enregistrées pour un utilisateur donné.
     
-    :param db_manager: Instance de DBManager.
-    :param id_utilisateur: ID de l'utilisateur.
-    :return: Liste des conversations.
+    Args:
+        db_manager: instance de DBManager.
+        id_utilisateur (int): ID de l'utilisateur.
+    Returns:
+        List[Dict]: liste des conversations.
     """
     query = """
-        SELECT * FROM conversations 
-        WHERE id_utilisateur = %s
+        SELECT id_conversation, created_at, title
+        FROM conversations 
+        WHERE id_utilisateur = ? 
         ORDER BY created_at DESC
     """
     try:
         result = db_manager.query(query, (id_utilisateur,))
-       
-
         return [
-            {"id_conversation": row["id_conversation"], "created_at": row["created_at"], "title": row["title"]} for row in result
+            {
+                "id_conversation": row["id_conversation"],
+                "created_at": row["created_at"],
+                "title": row["title"],
+            }
+            for row in result
         ]
-    except psycopg2.Error as err:
-        logger.error(f"Erreur de connexion : {err}")
-        return
+    except sqlite3.Error as err:  # Gestion des erreurs avec sqlite3
+        logger.error(f"Erreur lors du chargement des conversations : {err}")
+        return []
+
+
+# def update_conversation(db_manager, id_conversation: int, id_utilisateur: int) -> None:
+#     """
+#     Met à jour le champ `created_at` d'une conversation donnée pour un utilisateur.
+
+#     :param db_manager: Instance de DBManager.
+#     :param id_conversation: ID de la conversation à mettre à jour.
+#     :param id_utilisateur: ID de l'utilisateur.
+#     """
+#     new_timer = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+#     query = """
+#         UPDATE conversations
+#         SET created_at = %s
+#         WHERE id_conversation = %s AND id_utilisateur = %s
+#     """
+#     try:
+#         db_manager.query(query, (new_timer, id_conversation, id_utilisateur))
+#     except psycopg2.Error as err:
+#         logger.error(f"Erreur de connexion : {err}")
+#         return
+
 
 def update_conversation(db_manager, id_conversation: int, id_utilisateur: int) -> None:
     """
     Met à jour le champ `created_at` d'une conversation donnée pour un utilisateur.
     
-    :param db_manager: Instance de DBManager.
-    :param id_conversation: ID de la conversation à mettre à jour.
-    :param id_utilisateur: ID de l'utilisateur.
+    Args:
+        db_manager: instance de DBManager.
+        id_conversation (int): ID de la conversation à mettre à jour.
+        id_utilisateur (int): ID de l'utilisateur.
     """
     new_timer = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     query = """
         UPDATE conversations 
-        SET created_at = %s 
-        WHERE id_conversation = %s AND id_utilisateur = %s
+        SET created_at = ? 
+        WHERE id_conversation = ? AND id_utilisateur = ?
     """
     try:
         db_manager.query(query, (new_timer, id_conversation, id_utilisateur))
-    except psycopg2.Error as err:
-        logger.error(f"Erreur de connexion : {err}")
+    except sqlite3.Error as err:  # Utilisation de sqlite3.Error pour capturer les erreurs SQLite
+        logger.error(f"Erreur lors de la mise à jour de la conversation : {err}")
         return
 
+
+# def update_conversation_title(db_manager, id_conversation: int, new_title: str) -> None:
+#     """
+#     Met à jour le titre d'une conversation si celui-ci est encore "Nouvelle conversation".
+
+#     :param db_manager: Instance de DBManager.
+#     :param id_conversation: ID de la conversation à mettre à jour.
+#     :param new_title: Nouveau titre de la conversation.
+#     """
+#     query = """
+#         UPDATE conversations
+#         SET title = %s
+#         WHERE id_conversation = %s AND title = 'Nouvelle conversation'
+#     """
+#     try:
+#         db_manager.query(query, (new_title, id_conversation))
+#     except psycopg2.Error as err:
+#         logger.error(f"Erreur de connexion : {err}")
+#         return
+
+
 def update_conversation_title(db_manager, id_conversation: int, new_title: str) -> None:
     """
     Met à jour le titre d'une conversation si celui-ci est encore "Nouvelle conversation".
 
-    :param db_manager: Instance de DBManager.
-    :param id_conversation: ID de la conversation à mettre à jour.
-    :param new_title: Nouveau titre de la conversation.
+    Args:
+        db_manager: instance de DBManager.
+        id_conversation (int): ID de la conversation à mettre à jour.
+        new_title (str): nouveau titre de la conversation.
     """
     query = """
         UPDATE conversations 
-        SET title = %s
-        WHERE id_conversation = %s AND title = 'Nouvelle conversation'
+        SET title = ? 
+        WHERE id_conversation = ? AND title = 'Nouvelle conversation'
     """
     try:
         db_manager.query(query, (new_title, id_conversation))
-    except psycopg2.Error as err:
-        logger.error(f"Erreur de connexion : {err}")
+    except sqlite3.Error as err:  # Utilisation de sqlite3.Error pour gérer les erreurs SQLite
+        logger.error(
+            f"Erreur lors de la mise à jour du titre de la conversation : {err}"
+        )
         return
 
+
+# def get_conversation_title(db_manager, id_conversation: int) -> str:
+#     """
+#     Récupère le titre d'une conversation spécifique en utilisant `fetch_by_condition`.
+
+#     :param db_manager: Instance de DBManager.
+#     :param id_conversation: ID de la conversation à interroger.
+#     :return: Le titre de la conversation ou "Nouvelle conversation".
+#     """
+#     table_name = "conversations"
+#     condition = "id_conversation = %s"
+#     try:
+#         results = db_manager.fetch_by_condition(table_name, condition, (id_conversation,))
+#         if results:
+#             # Suppose que `title` est la troisième colonne
+#             return results[0][2]
+#         return "Nouvelle conversation"
+#     except psycopg2.Error as err:
+#         logger.error(f"Erreur de connexion : {err}")
+#         return
+
+
 def get_conversation_title(db_manager, id_conversation: int) -> str:
     """
     Récupère le titre d'une conversation spécifique en utilisant `fetch_by_condition`.
 
-    :param db_manager: Instance de DBManager.
-    :param id_conversation: ID de la conversation à interroger.
-    :return: Le titre de la conversation ou "Nouvelle conversation".
+    Args:
+        db_manager: instance de DBManager.
+        id_conversation (int): ID de la conversation à interroger.
+    
+    Returns:
+        str: le titre de la conversation ou "Nouvelle conversation".
     """
     table_name = "conversations"
-    condition = "id_conversation = %s"
+    condition = "id_conversation = ?"
     try:
-        results = db_manager.fetch_by_condition(table_name, condition, (id_conversation,))
+        results = db_manager.fetch_by_condition(
+            table_name, condition, (id_conversation,)
+        )
         if results:
-            # Suppose que `title` est la troisième colonne
-            return results[0][2]
+            # Assume that `title` is the second column
+            return results[0][
+                1
+            ]  # 1 corresponds to the index of the title column in the result
         return "Nouvelle conversation"
-    except psycopg2.Error as err:
-        logger.error(f"Erreur de connexion : {err}")
-        return
+    except sqlite3.Error as err:  # Utilisation de sqlite3.Error pour gérer les erreurs SQLite
+        logger.error(
+            f"Erreur lors de la récupération du titre de la conversation : {err}"
+        )
+        return "Nouvelle conversation"
+
+
+# def delete_conversation(db_manager, id_conversation: int) -> None:
+#     """
+#     Supprime une conversation et ses messages associés de la base de données.
+
+#     :param db_manager: Instance de DBManager.
+#     :param id_conversation: ID de la conversation à supprimer.
+#     """
+#     try:
+#         # Supprimer les messages liés à la conversation
+#         query_delete_messages = "DELETE FROM messages WHERE id_conversation = %s"
+#         db_manager.query(query_delete_messages, (id_conversation,))
+
+#         # Supprimer la conversation elle-même
+#         query_delete_conversation = "DELETE FROM conversations WHERE id_conversation = %s"
+#         db_manager.query(query_delete_conversation, (id_conversation,))
+
+#         print(f"✅ Conversation {id_conversation} supprimée avec succès.")
+#     except Exception as e:
+#         print(f"❌ Erreur lors de la suppression de la conversation {id_conversation}: {e}")
+
 
 def delete_conversation(db_manager, id_conversation: int) -> None:
     """
     Supprime une conversation et ses messages associés de la base de données.
 
-    :param db_manager: Instance de DBManager.
-    :param id_conversation: ID de la conversation à supprimer.
+    Args:
+        db_manager: instance de DBManager.
+        id_conversation (int): ID de la conversation à supprimer.
     """
     try:
         # Supprimer les messages liés à la conversation
-        query_delete_messages = "DELETE FROM messages WHERE id_conversation = %s"
+        query_delete_messages = "DELETE FROM messages WHERE id_conversation = ?"
         db_manager.query(query_delete_messages, (id_conversation,))
 
         # Supprimer la conversation elle-même
-        query_delete_conversation = "DELETE FROM conversations WHERE id_conversation = %s"
+        query_delete_conversation = (
+            "DELETE FROM conversations WHERE id_conversation = ?"
+        )
         db_manager.query(query_delete_conversation, (id_conversation,))
 
-        print(f"✅ Conversation {id_conversation} supprimée avec succès.")
-    except Exception as e:
-        print(f"❌ Erreur lors de la suppression de la conversation {id_conversation}: {e}")
+        logger.info(f"✅ Conversation {id_conversation} supprimée avec succès.")
+        # print(f"✅ Conversation {id_conversation} supprimée avec succès.")
+    except sqlite3.Error as e:  # Utilisation de sqlite3.Error pour capturer les erreurs SQLite
+        logger.error(
+            f"❌ Erreur lors de la suppression de la conversation {id_conversation}: {e}"
+        )
+        # print(f"❌ Erreur lors de la suppression de la conversation {id_conversation}: {e}")
+
+
+# def load_chatbot_suggestions(db_manager, user_id):
+#     """
+#     Charge les suggestions du chatbot enregistrées pour un utilisateur donné.
+#     """
+#     query = "SELECT repas_suggestion FROM suggestions_repas WHERE id_utilisateur = %s"
+#     try:
+#         db_manager.cursor.execute(query, (user_id,))
+#         suggestions = [row[0] for row in db_manager.cursor.fetchall()]
+#         return suggestions
+#     except psycopg2.Error as err:
+#         logger.error(f"Erreur lors du chargement des suggestions : {err}")
+#         return []
 
-def load_chatbot_suggestions(db_manager, user_id):
+
+def load_chatbot_suggestions(db_manager, user_id: str) -> List[Tuple]:
     """
     Charge les suggestions du chatbot enregistrées pour un utilisateur donné.
+
+    Args:
+        db_manager: instance de DBManager.
+        user_id (int): ID de l'utilisateur.
+
+    Returns:
+        List[Tuple]: list des suggestions du chatbot.
     """
-    query = "SELECT repas_suggestion FROM suggestions_repas WHERE id_utilisateur = %s"
+    query = "SELECT repas_suggestion FROM suggestions_repas WHERE id_utilisateur = ?"
     try:
         db_manager.cursor.execute(query, (user_id,))
         suggestions = [row[0] for row in db_manager.cursor.fetchall()]
         return suggestions
-    except psycopg2.Error as err:
+    except sqlite3.Error as err:  # Utilisation de sqlite3.Error pour capturer les erreurs SQLite
         logger.error(f"Erreur lors du chargement des suggestions : {err}")
         return []
 
 
+# def save_chatbot_suggestions(db_manager, user_id, suggestions):
+#     """
+#     Sauvegarde les suggestions du chatbot dans la base de données.
+#     """
+#     query = """
+#     INSERT INTO suggestions_repas (id_utilisateur, repas_suggestion, motif_suggestion)
+#     VALUES (%s, %s, %s)
+#     """
+#     try:
+#         for suggestion in suggestions:
+#             db_manager.cursor.execute(query, (user_id, suggestion, "Chatbot"))
+#         db_manager.connection.commit()
+#     except psycopg2.Error as err:
+#         logger.error(f"Erreur lors de l'enregistrement des suggestions : {err}")
 
-def save_chatbot_suggestions(db_manager, user_id, suggestions):
+
+def save_chatbot_suggestions(db_manager, user_id, suggestions: List[Tuple]):
     """
     Sauvegarde les suggestions du chatbot dans la base de données.
+
+    Args:
+        db_manager: instance de DBManager.
+        user_id (int): ID de l'utilisateur.
+        suggestions (List[Tuple]): list des suggestions du chatbot.
+
     """
     query = """
     INSERT INTO suggestions_repas (id_utilisateur, repas_suggestion, motif_suggestion) 
-    VALUES (%s, %s, %s)
+    VALUES (?, ?, ?)
     """
     try:
         for suggestion in suggestions:
             db_manager.cursor.execute(query, (user_id, suggestion, "Chatbot"))
         db_manager.connection.commit()
-    except psycopg2.Error as err:
+    except sqlite3.Error as err:  # Remplacer psycopg2.Error par sqlite3.Error pour SQLite
         logger.error(f"Erreur lors de l'enregistrement des suggestions : {err}")
-
-

server/db/schema.json

@@ -1,85 +1,3 @@
-{
-  "tables": {
-    "utilisateurs": {
-      "columns": [
-        {"name": "id_utilisateur", "type": "SERIAL", "constraints": ["PRIMARY KEY"]},
-        {"name": "login", "type": "TEXT", "constraints": ["UNIQUE", "NOT NULL"]},
-        {"name": "mot_de_passe", "type": "TEXT", "constraints": ["NOT NULL"]},
-        {"name": "nom", "type": "TEXT", "constraints": []},
-        {"name": "objectifs_nutritionnels", "type": "TEXT", "constraints": []},
-        {"name": "poids", "type": "INTEGER", "constraints": []},
-        {"name": "Taille", "type": "INTEGER", "constraints": []},
-        {"name": "activite_physique", "type": "TEXT", "constraints": []},
-        {"name": "objectif_calorique", "type": "TEXT", "constraints": []},
-        {"name": "regime_particulier", "type": "TEXT", "constraints": []},
-        {"name": "email", "type": "TEXT", "constraints": []},
-        {"name": "date_creation", "type": "TIMESTAMP", "constraints": ["DEFAULT CURRENT_TIMESTAMP"]},
-        {"name": "date_derniere_connexion", "type": "TIMESTAMP", "constraints": []}
-      ]
-    },
-    "recettes": {
-      "columns": [
-        {"name": "id_recette", "type": "SERIAL", "constraints": ["PRIMARY KEY"]},
-        {"name": "titre", "type": "TEXT", "constraints": ["NOT NULL"]},
-        {"name": "infos", "type": "TEXT", "constraints": []},
-        {"name": "ingredients", "type": "TEXT", "constraints": ["NOT NULL"]},
-        {"name": "instructions", "type": "TEXT", "constraints": ["NOT NULL"]},
-        {"name": "temps_preparation", "type": "TEXT", "constraints": []},
-        {"name": "infos_regime", "type": "TEXT", "constraints": []},
-        {"name": "valeurs_100g", "type": "TEXT", "constraints": []},
-        {"name": "valeurs_portion", "type": "TEXT", "constraints": []},
-        {"name": "all_infos", "type": "TEXT", "constraints": []},
-        {"name": "cleaned_infos", "type": "TEXT", "constraints": []},
-        {"name": "cluster2", "type": "INTEGER", "constraints": []}
-      ]
-    },
-    "historique_repas": {
-      "columns": [
-        {"name": "id_historique", "type": "SERIAL", "constraints": ["PRIMARY KEY"]},
-        {"name": "id_utilisateur", "type": "INTEGER", "constraints": ["NOT NULL", "REFERENCES utilisateurs(id_utilisateur)"]},
-        {"name": "id_recette", "type": "INTEGER", "constraints": ["NOT NULL", "REFERENCES recettes(id_recette)"]},
-        {"name": "date_heure", "type": "TIMESTAMP", "constraints": ["DEFAULT CURRENT_TIMESTAMP"]},
-        {"name": "quantite", "type": "INTEGER", "constraints": []}
-      ]
-    },
-    "conversations": {
-      "columns": [
-        {"name": "id_conversation", "type": "SERIAL", "constraints": ["PRIMARY KEY"]},
-        {"name": "id_utilisateur", "type": "INTEGER", "constraints": ["NOT NULL", "REFERENCES utilisateurs(id_utilisateur)"]},
-        {"name": "title", "type": "TEXT", "constraints": ["NOT NULL"]},
-        {"name": "created_at", "type": "TIMESTAMP", "constraints": ["NOT NULL"]}
-      ]
-    },
-    "messages": {
-      "columns": [
-        {"name": "id_message", "type": "SERIAL", "constraints": ["PRIMARY KEY"]},
-        {"name": "id_conversation", "type": "INTEGER", "constraints": ["NOT NULL", "REFERENCES conversations(id_conversation)"]},
-        {"name": "role", "type": "TEXT", "constraints": ["NOT NULL"]},
-        {"name": "content", "type": "TEXT", "constraints": ["NOT NULL"]},
-        {"name": "timestamp", "type": "TIMESTAMP", "constraints": ["DEFAULT CURRENT_TIMESTAMP"]},
-        {"name": "temps_traitement", "type": "REAL", "constraints": []},
-        {"name": "contexte", "type": "TEXT", "constraints": []},
-        {"name": "total_cout", "type": "REAL", "constraints": []},
-        {"name": "impact_eco", "type": "REAL", "constraints": []}
-      ]
-    },
-    "liste_courses": {
-      "columns": [
-        {"name": "id_liste", "type": "SERIAL", "constraints": ["PRIMARY KEY"]},
-        {"name": "id_utilisateur", "type": "INTEGER", "constraints": ["NOT NULL", "REFERENCES utilisateurs(id_utilisateur)"]},
-        {"name": "ingredients", "type": "TEXT", "constraints": ["NOT NULL"]},
-        {"name": "date_creation", "type": "TIMESTAMP", "constraints": ["DEFAULT CURRENT_TIMESTAMP"]},
-        {"name": "status", "type": "TEXT", "constraints": []}
-      ]
-    },
-    "suggestions_repas": {
-      "columns": [
-        {"name": "id_suggestion", "type": "SERIAL", "constraints": ["PRIMARY KEY"]},
-        {"name": "id_utilisateur", "type": "INTEGER", "constraints": ["NOT NULL", "REFERENCES utilisateurs(id_utilisateur)"]},
-        {"name": "repas_suggestion", "type": "TEXT", "constraints": ["NOT NULL"]},
-        {"name": "date_heure", "type": "TIMESTAMP", "constraints": ["DEFAULT CURRENT_TIMESTAMP"]},
-        {"name": "motif_suggestion", "type": "TEXT", "constraints": []}
-      ]
-    }
-  }
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:92b0932c8f60048b055922f2022bccf01e3558d75e547e3a0b0a22634328ae4d
+size 4830

server/db/schema_postgreSQL.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97dd9dd3388d2749d3690c7f6fa7bc2ae4e3d91eca472f89b7f8016620c99c02
+size 5018