Version fonctionnelle

app/domo91.py

@@ -6,7 +6,8 @@ import matplotlib.pyplot as plt
 import matplotlib.dates as mdates
 import os
 from dotenv import load_dotenv
-from datetime import datetime, date
+from datetime import datetime, date, time
+from fpdf import FPDF
 import bcrypt
 import traceback
 import random
@@ -64,7 +65,7 @@ if not st.session_state.get("authenticated", False):
 
             # On interroge la bonne table
             cursor.execute("""
-                           SELECT NomUtilisateur, MotDePasseHash, role, Site, DateExpiration
+                           SELECT NomUtilisateur, role, MotDePasseHash, Site, DateExpiration
                            FROM Acces.Utilisateurs
                            WHERE NomUtilisateur = %s
                            LIMIT 1
@@ -105,50 +106,184 @@ else:
             st.session_state[key] = False if key == "authenticated" else None
         st.rerun()
 
-# --- Bandeau Alertes ---
-try:
-    conn = get_connection()
-    cursor = conn.cursor(dictionary=True)
 
-    # Récupérer le site autorisé depuis la session
-    site = st.session_state.get("lieu_autorise")
 
-    if site:
-        # Lecture des alertes non acquittées pour ce site
-        cursor.execute(f"""
-            SELECT Id, Sonde, Debut_defaut, Etat
-            FROM Alertes_{site}
-            WHERE Etat != 'Acquitté'
-            ORDER BY Debut_defaut DESC
-        """)
-        alertes = cursor.fetchall()
+# --- Fonction de génération PDF ---
+def generer_pdf(site, date_str, periode):
+    st.info(f"Génération du rapport PDF pour {site} à la date {date_str} ({periode})")
+    try:
+        conn = mysql.connector.connect(**db_config)
+        pdf_cursor = conn.cursor(dictionary=True)
 
-        if alertes:
-            st.markdown(
-                f"<div style='background-color:#ffcccc;padding:10px;border-radius:8px;'>"
-                f"🚨 <b>{len(alertes)} alerte(s) non résolue(s)</b> sur <b>{site}</b>"
-                f"</div>",
-                unsafe_allow_html=True
-            )
+        # Requête principale
+        pdf_cursor.execute(f"SELECT Sonde, Date, Temperature FROM `{site}` WHERE DATE(Date) = %s ORDER BY Sonde, Date", (date_str,))
+        rows = pdf_cursor.fetchall()
+        df = pd.DataFrame(rows)
+        df["Heure"] = pd.to_datetime(df["Date"]).dt.strftime("%H:%M")
+        df["Heure_obj"] = pd.to_datetime(df["Date"]).dt.time
+
+        # --- Filtrage par période ---
+        plages = {
+            "Toute la journée": (time(0, 0), time(23, 59)),
+            "Matin (6h-12h)": (time(6, 0), time(12, 0)),
+            "Après-midi (12h-18h)": (time(12, 0), time(18, 0)),
+            "Nuit (18h-6h)": (time(18, 0), time(6, 0)),
+        }
+        heure_debut, heure_fin = plages.get(periode, (time(0, 0), time(23, 59)))
+        if heure_debut < heure_fin:
+            df = df[(df["Heure_obj"] >= heure_debut) & (df["Heure_obj"] <= heure_fin)]
         else:
-            st.markdown(
-                f"<div style='background-color:#ccffcc;padding:10px;border-radius:8px;'>"
-                f"✅ Aucune alerte en cours sur <b>{site}</b>"
-                f"</div>",
-                unsafe_allow_html=True
+            df = df[(df["Heure_obj"] >= heure_debut) | (df["Heure_obj"] <= heure_fin)]
+
+        # --- Structuration des relevés ---
+        releves = {}
+        for sonde in df["Sonde"].unique():
+            df_sonde = df[df["Sonde"] == sonde]
+            releves[sonde] = list(zip(df_sonde["Heure"], df_sonde["Temperature"]))
+
+        # --- Requête alertes ---
+        table_alertes = f"Alertes_{site}"
+        pdf_cursor.execute(f"SELECT Sonde, Debut_defaut, Status FROM {table_alertes} WHERE DATE(Debut_defaut) = %s", (date_str,))
+        alertes = pdf_cursor.fetchall()
+
+        pdf_cursor.close()
+        conn.close()
+
+        # --- Classe PDF ---
+        class RapportPDF(FPDF):
+            def header(self):
+                self.set_font("Arial", "B", 14)
+                self.cell(0, 10, "Rapport de surveillance des sondes", ln=1, align="C")
+                self.set_font("Arial", "", 12)
+                self.cell(0, 10, f"Date : {date_str}", ln=1, align="C")
+                self.cell(0, 10, f"Periode : {getattr(self, 'periode', '')}", ln=1, align="C")
+                self.ln(5)
+
+            def site_info(self, site_name):
+                self.set_font("Arial", "B", 12)
+                self.cell(0, 10, f"Site : {site_name}", ln=1)
+                self.ln(2)
+
+            def releves_section(self, data):
+                self.set_font("Arial", "B", 12)
+                self.cell(0, 10, "Relevés de température", ln=1)
+
+                for sonde, mesures in data.items():
+                    self.set_font("Arial", "B", 11)
+                    self.cell(0, 8, f"Sonde : {sonde}", ln=1)
+
+                    col1 = mesures[::2]
+                    col2 = mesures[1::2]
+
+                    self.set_font("Arial", "B", 10)
+                    self.cell(40, 6, "Heure", border=1)
+                    self.cell(30, 6, "Temp (°C)", border=1)
+                    self.cell(20, 6, "", border=0)
+                    self.cell(40, 6, "Heure", border=1)
+                    self.cell(30, 6, "Temp (°C)", border=1)
+                    self.ln()
+
+                    self.set_font("Arial", "", 10)
+                    for i in range(max(len(col1), len(col2))):
+                        if i < len(col1):
+                            h1, t1 = col1[i]
+                            self.cell(40, 6, h1, border=1)
+                            self.cell(30, 6, f"{t1:.2f}", border=1)
+                        else:
+                            self.cell(70, 6, "", border=0)
+                        self.cell(20, 6, "", border=0)
+                        if i < len(col2):
+                            h2, t2 = col2[i]
+                            self.cell(40, 6, h2, border=1)
+                            self.cell(30, 6, f"{t2:.2f}", border=1)
+                        self.ln()
+                    self.ln(4)
+
+            def alertes_section(self, data):
+                self.set_font("Arial", "B", 12)
+                self.cell(0, 10, "Alertes enregistrées", ln=1)
+                self.set_font("Arial", "", 10)
+                for a in data:
+                    self.cell(0, 6, f"{a['Sonde']} - {a['Debut_defaut']} - {a['Status']}", ln=1)
+
+        # --- Génération du PDF ---
+        pdf = RapportPDF()
+        pdf.periode = periode
+        pdf.add_page()
+        pdf.site_info(site)
+        pdf.releves_section(releves)
+        pdf.alertes_section(alertes)
+
+        file_name = f"rapport_{site}_{date_str}.pdf"
+        output_dir = "PDF"
+        os.makedirs(output_dir, exist_ok=True)
+        output_path = os.path.join(output_dir, file_name)
+
+        pdf.output(output_path)
+
+        with open(output_path, "rb") as f:
+            st.download_button(
+                label="📥 Télécharger le rapport PDF",
+                data=f,
+                file_name=file_name,
+                mime="application/pdf"
             )
 
-    cursor.close()
-    conn.close()
+    except Exception as err1:
+        st.error(f"Erreur lors de la génération du PDF : {err1}")
 
-except Exception as e:
-    st.error(f"Erreur lors de la récupération des alertes : {e}")
+# --- AFFICHAGE GLOBAL DES ALERTES NON ACQUITTÉES ---
+if st.session_state.get("authenticated"):
+    try:
+        role = st.session_state.get("role")
+        # si superviseur → utilise selected_site (par défaut Saclay)
+        # sinon → utilise site_autorise (imposé à la connexion)
+        site_selectionne = (
+            st.session_state.get("site_autorise")
+            if role != "superviseur"
+            else st.session_state.get("selected_site", "Saclay")
+        )
 
+        if not site_selectionne:
+            # pas de site → on n’essaie pas de lire la table
+            st.info("Connectez-vous et choisissez un site pour afficher les alertes.")
+        else:
+            conn = mysql.connector.connect(**db_config)
+            cursor = conn.cursor(dictionary=True)
+
+            # Optionnel: whitelist pour éviter toute injection sur le nom de table
+            SITES_AUTORISES = {"Saclay", "Meudon", "Roissy"}
+            if site_selectionne not in SITES_AUTORISES:
+                raise ValueError(f"Site invalide: {site_selectionne}")
+
+            table_alertes = f"Alertes_{site_selectionne}"
+            cursor.execute(
+                f"SELECT Sonde, Debut_defaut, Status "
+                f"FROM `{table_alertes}` "
+                f"WHERE Status != 'Acquitté' "
+                f"ORDER BY Debut_defaut DESC"
+            )
+            alertes = cursor.fetchall()
+
+            if alertes:
+                df_alertes = pd.DataFrame(alertes)
+                st.subheader("🚨 Alertes non acquittées")
+                st.dataframe(df_alertes, use_container_width=True)
+            else:
+                st.success("✅ Aucune alerte en cours.")
+
+            cursor.close()
+            conn.close()
+
+    except Exception as e:
+        st.error(f"Erreur lors de la récupération des alertes : {e}")
+else:
+    st.info("Connectez-vous pour voir les alertes en cours.")
 
 # --- Navigation ---
 if st.session_state["authenticated"]:
     onglets = ["Accueil", "Entretien"] if st.session_state["role"] != "superviseur" else ["Accueil", "Statistiques",
-                                                                                          "Entretien"]
+                                                                                          "Entretien", "Traffic"]
     onglet_selectionne = st.sidebar.radio("📁 Navigation", onglets,
                                           index=onglets.index(st.session_state["onglet_actif"]))
     st.session_state["onglet_actif"] = onglet_selectionne
@@ -189,7 +324,13 @@ if st.session_state["authenticated"]:
                 tranche = st.radio("🕒 Tranche horaire :",
                                    ["Toute la journée", "Matin (6h-12h)", "Après-midi (12h-18h)", "Nuit (18h-6h)"])
                 st.session_state["selected_periode"] = tranche
-
+                # Bouton de génération du PDF
+                if st.button("🧾 Générer le PDF du jour"):
+                    generer_pdf(
+                        site_actuel,
+                        date_selectionnee.strftime("%Y-%m-%d"),
+                        st.session_state.get("selected_periode", "Toute la journée")
+                    )
                 if tranche == "Matin (6h-12h)":
                     df_sonde = df_sonde[(df_sonde["Heure"] >= 6) & (df_sonde["Heure"] < 12)]
                 elif tranche == "Après-midi (12h-18h)":
@@ -372,7 +513,8 @@ if st.session_state["authenticated"]:
             conn = get_connection()
             cursor = conn.cursor(dictionary=True)
             cursor.execute(
-                "SELECT Utilisateur, Lieu, Date_Connexion FROM Connexion_Log ORDER BY Date_Connexion DESC LIMIT 100")
+                "SELECT Utilisateur, Lieu, Date_Connexion FROM Sondes.Connexion_Log ORDER BY Date_Connexion DESC LIMIT 100"
+            )
             logs = cursor.fetchall()
             df_logs = pd.DataFrame(logs)
             st.dataframe(df_logs)