From 0d3c43471ad2d0f815adf667559080d642d6ffd6 Mon Sep 17 00:00:00 2001 From: Michel Date: Sat, 19 Apr 2025 10:31:32 +0200 Subject: [PATCH] =?UTF-8?q?=F0=9F=86=95=20Maj=20du=2019/04/2025?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Backup_Synology/Chat-Id.py | 36 +++ Backup_Synology/Cuisine_meudon.py | 30 +++ Backup_Synology/Cuisine_saclay.py | 30 +++ Backup_Synology/Monitor.py | 127 +++++++++++ Backup_Synology/README.md | 52 +++++ Backup_Synology/Societe_Generale.py | 107 +++++++++ Backup_Synology/Test_mail.py | 24 ++ Backup_Synology/Tracker.py | 106 +++++++++ Backup_Synology/domo91.py | 331 ++++++++++++++++++++++++++++ Chaufferie.py | 30 +++ Purge_Alertes_saclay.py | 18 ++ Telegram_sondes.py | 324 +++++++++++++++++++++++++++ logs_analyse.py | 39 ++++ supervisor_watchdog.py | 47 ++++ 14 files changed, 1301 insertions(+) create mode 100644 Backup_Synology/Chat-Id.py create mode 100644 Backup_Synology/Cuisine_meudon.py create mode 100644 Backup_Synology/Cuisine_saclay.py create mode 100644 Backup_Synology/Monitor.py create mode 100644 Backup_Synology/README.md create mode 100644 Backup_Synology/Societe_Generale.py create mode 100644 Backup_Synology/Test_mail.py create mode 100644 Backup_Synology/Tracker.py create mode 100644 Backup_Synology/domo91.py create mode 100644 Chaufferie.py create mode 100644 Purge_Alertes_saclay.py create mode 100644 Telegram_sondes.py create mode 100644 logs_analyse.py create mode 100644 supervisor_watchdog.py diff --git a/Backup_Synology/Chat-Id.py b/Backup_Synology/Chat-Id.py new file mode 100644 index 0000000..a5bd401 --- /dev/null +++ b/Backup_Synology/Chat-Id.py @@ -0,0 +1,36 @@ +import requests +import json + +# Remplace par ton token de bot Telegram +token = "8128378340:AAF2sO3gaH1XpMNya_pEslzerqokoCiFRGs" + +url = f"https://api.telegram.org/bot{token}/getUpdates" + +try: + response = requests.get(url) + data = response.json() + + print("🔍 Récupération des chats Telegram récents...\n") + + if "result" in data: + chats = set() + + for update in data["result"]: + message = update.get("message") or update.get("edited_message") + if not message: + continue + + chat = message["chat"] + chat_id = chat["id"] + chat_title = chat.get("title") or chat.get("username") or chat.get("first_name") or "Inconnu" + + if chat_id not in chats: + chats.add(chat_id) + print(f"➡️ Chat : {chat_title} | ID : {chat_id}") + + if not chats: + print("⚠️ Aucun chat trouvé. Envoie un message depuis un groupe ou une discussion avec le bot.") + else: + print("❌ Erreur : aucune donnée 'result' trouvée dans la réponse.") +except Exception as e: + print(f"Erreur lors de la récupération des chats : {e}") diff --git a/Backup_Synology/Cuisine_meudon.py b/Backup_Synology/Cuisine_meudon.py new file mode 100644 index 0000000..e8c1b05 --- /dev/null +++ b/Backup_Synology/Cuisine_meudon.py @@ -0,0 +1,30 @@ +import paho.mqtt.client as mqttClient +client = mqttClient.Client() +import mysql.connector +import sys +sys.path.insert(0, "/myenv/lib/python3.11.2/site-packages") + +# Configuration de la connexion MySQL +mydb = mysql.connector.connect( + host="54.36.188.119", + user="michel", + password="#SO2&1nf%mZ@jfh", + database="Sondes" +) + +# Fonction de callback quand un message est reçu +def on_message(_client, _userdata, msg): + print(f"Message reçu sur {msg.topic}: {msg.payload.decode()}") + cursor = mydb.cursor() + frigo_name = msg.topic.split('/')[-1] # Prend la dernière partie après le "/" + sql = "INSERT INTO Meudon (Sonde, Temperature) VALUES (%s, %s)" + val = (frigo_name, msg.payload.decode()) + cursor.execute(sql, val) + mydb.commit() + +# Configuration du client MQTT +client.username_pw_set("Bwps", "scJ5ACj2keRfI^") +client.on_message = on_message +client.connect("54.36.188.119", 1883, 60) +client.subscribe("Meudon/#") # S'abonner à tous les topics commençant par Saclay +client.loop_forever() # Rester connecté en continu pour écouter les messages diff --git a/Backup_Synology/Cuisine_saclay.py b/Backup_Synology/Cuisine_saclay.py new file mode 100644 index 0000000..4e68428 --- /dev/null +++ b/Backup_Synology/Cuisine_saclay.py @@ -0,0 +1,30 @@ +import paho.mqtt.client as mqttClient +client = mqttClient.Client() +import mysql.connector +import sys +sys.path.insert(0, "/myenv/lib/python3.11.2/site-packages") + +# Configuration de la connexion MySQL +mydb = mysql.connector.connect( + host="54.36.188.119", + user="michel", + password="#SO2&1nf%mZ@jfh", + database="Sondes" +) + +# Fonction de callback quand un message est reçu +def on_message(_client, _userdata, msg): + print(f"Message reçu sur {msg.topic}: {msg.payload.decode()}") + cursor = mydb.cursor() + frigo_name = msg.topic.split('/')[-1] # Prend la dernière partie après le "/" + sql = "INSERT INTO Saclay (Sonde, Temperature) VALUES (%s, %s)" + val = (frigo_name, msg.payload.decode()) + cursor.execute(sql, val) + mydb.commit() + +# Configuration du client MQTT +client.username_pw_set("Bwps", "scJ5ACj2keRfI^") +client.on_message = on_message +client.connect("54.36.188.119", 1883, 60) +client.subscribe("Saclay/#") # S'abonner à tous les topics commençant par Saclay +client.loop_forever() # Rester connecté en continu pour écouter les messages diff --git a/Backup_Synology/Monitor.py b/Backup_Synology/Monitor.py new file mode 100644 index 0000000..471f43c --- /dev/null +++ b/Backup_Synology/Monitor.py @@ -0,0 +1,127 @@ +# Surveillance continue avec envoi d'alertes par email + log CSV +import mysql.connector +from datetime import datetime, timedelta +import time +import smtplib +from email.mime.text import MIMEText +import pandas as pd + +# --- Config MySQL --- +config = { + "host": "54.36.188.119", + "user": "michel", + "password": "#SO2&1nf%mZ@jfh", + "database": "Sondes" +} + +# --- Destinataires email --- +destinataires = ['services@domo91.fr'] + +# --- Fonction d'envoi de mail --- +def envoyer_mail(sujet, message, destinataires): + msg = MIMEText(message) + msg['Subject'] = sujet + msg['From'] = 'alertes_saclay@domo91.fr' + msg['To'] = ', '.join(destinataires) + try: + with smtplib.SMTP_SSL('smtp.mail.ovh.net', 465) as server: + server.login('alertes_saclay@domo91.fr', 'Kdpke674y23Feq^H') + server.sendmail(msg['From'], destinataires, msg.as_string()) + print(f"📧 Mail envoyé à {destinataires}", flush=True) + except Exception as e: + print(f"Erreur envoi mail : {e}", flush=True) + +# --- Fonction de surveillance --- +def surveiller(): + log_entries = [] + try: + conn = mysql.connector.connect(**config) + cursor = conn.cursor(dictionary=True) + + cursor.execute("SELECT DISTINCT Lieu FROM Chambres_froides") + lieux = [row['Lieu'] for row in cursor.fetchall()] + + for lieu in lieux: + table_temp = lieu + table_alertes = f"Alertes_{lieu}" + + cursor.execute("SELECT Sonde, Temp_Max FROM Chambres_froides WHERE Lieu=%s AND Etat='ON'", (lieu,)) + sondes = cursor.fetchall() + + for sonde in sondes: + nom_sonde = sonde['Sonde'] + seuil = sonde['Temp_Max'] + + cursor.execute(f""" + SELECT Date, Temperature FROM {table_temp} + WHERE Sonde = %s + ORDER BY Date DESC LIMIT 6 + """, (nom_sonde,)) + relevés = cursor.fetchall() + + # Log CSV : tous les relevés analysés + for r in relevés: + log_entries.append({ + "Date": r['Date'], + "Lieu": lieu, + "Sonde": nom_sonde, + "Température": r['Temperature'], + "Seuil": seuil, + "État": "Dépassement" if r['Temperature'] > seuil else "Normal" + }) + + if len(relevés) == 6: + toutes_hors_seuil = all(r['Temperature'] > seuil for r in relevés) + plus_ancien = relevés[-1]['Date'] + maintenant = datetime.now() + + if toutes_hors_seuil and (maintenant - plus_ancien >= timedelta(minutes=30)): + cursor.execute(f""" + SELECT COUNT(*) as total FROM {table_alertes} + WHERE Sonde=%s AND Status='En cours' + """, (nom_sonde,)) + en_cours = cursor.fetchone() + if en_cours['total'] == 0: + cursor.execute( + f"INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status) VALUES (%s, NOW(), 'En cours')", + (nom_sonde,) + ) + print(f"🚨 Alerte déclenchée pour {nom_sonde} ({lieu})", flush=True) + sujet = f"🚨 ALERTE TEMPÉRATURE - {nom_sonde} ({lieu})" + message = ( + f"La sonde '{nom_sonde}' du site '{lieu}' a dépassé le seuil de {seuil}°C " + f"depuis plus de 30 minutes.\nHeure : {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}" + ) + envoyer_mail(sujet, message, destinataires) + + # Acquittement automatique + cursor.execute(f""" + SELECT Temperature FROM {table_temp} + WHERE Sonde = %s + ORDER BY Date DESC LIMIT 1 + """, (nom_sonde,)) + derniere = cursor.fetchone() + if derniere and derniere['Temperature'] <= seuil: + cursor.execute(f""" + UPDATE {table_alertes} + SET Status = 'Acquitté' + WHERE Sonde = %s AND Status = 'En cours' + """, (nom_sonde,)) + + conn.commit() + cursor.close() + conn.close() + + # Enregistrer le log + if log_entries: + df_logs = pd.DataFrame(log_entries) + df_logs.to_csv("/home/debian/travail/Logs/monitor.csv", sep=";", index=False) + + except Exception as e: + print(f"Erreur : {e}", flush=True) + +# --- Boucle principale --- +while True: + print(f"📡 Vérification à {datetime.now()}", flush=True) + surveiller() + time.sleep(300) # 5 minutes diff --git a/Backup_Synology/README.md b/Backup_Synology/README.md new file mode 100644 index 0000000..d91c980 --- /dev/null +++ b/Backup_Synology/README.md @@ -0,0 +1,52 @@ +# 🌡️ Gestion des sondes domotiques + +[![Version Python](https://img.shields.io/badge/Python-3.10-blue)](https://python.org) +[![Licence](https://img.shields.io/badge/Licence-Propriétaire-orange)](https://mj91.fr:448/michel/Gestion_sondes) +[![Gitea](https://img.shields.io/badge/Gitea-auto--hébergé-green)](https://mj91.fr:448) + +Application de **surveillance des températures** avec alertes, visualisation Streamlit, et déploiement automatisé via Gitea + Supervisor. + +--- + +## 🧩 Fonctionnalités principales + +- 🔍 Lecture de capteurs **DS18B20** et **DHT22** +- 📨 Transmission via **MQTT** +- 📊 Interface **Streamlit** (app.domo91.fr) +- 🔔 Alertes **email / Telegram** si dépassement > 30 minutes +- 🧠 Déploiement auto avec **`deploy.sh`** +- 🧾 Stockage SQL sur **MySQL (VPS)** + +--- + +## 📊 Exemple de visualisation + +Voici un aperçu d’un graphique dans l’interface Streamlit : + +![Exemple de graphique Streamlit](https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Matplotlib_figure.svg/800px-Matplotlib_figure.svg.png) + +--- + +## 🗂️ Structure du projet + +| Fichier | Description | +|-----------------------------|---------------------------------------------------------------------| +| `Monitor.py` | Analyse de température et alertes | +| `Streamlit.py` | Interface graphique web | +| `Cuisine_saclay.py` | Script capteur pour le site de Saclay | +| `Cuisine_meudon.py` | Script capteur pour Meudon | +| `check_supervisor.py` | Vérifie l’état des scripts supervisés | +| `deploy.sh` | Déploiement auto depuis Gitea (branche `product`) | +| `requirements.txt` | Dépendances Python | + +--- + +## 🧪 Installation locale + +```bash +git clone https://mj91.fr:448/michel/Gestion_sondes.git +cd Gestion_sondes +python -m venv .venv +source .venv/bin/activate # Linux/macOS +.venv\Scripts\activate # Windows +pip install -r requirements.txt diff --git a/Backup_Synology/Societe_Generale.py b/Backup_Synology/Societe_Generale.py new file mode 100644 index 0000000..88c100c --- /dev/null +++ b/Backup_Synology/Societe_Generale.py @@ -0,0 +1,107 @@ +# Insertion de données da l'app SG. +import streamlit as st +import mysql.connector +from dotenv import load_dotenv +import os +from datetime import datetime + +load_dotenv() + +st.set_page_config(page_title="Insertion Mysql", layout="centered") +st.title("🗓️ Insertion dans une base MySQL") + +# Charger les identifiants +DB_HOST = os.getenv("DB_HOST") +DB_USER = os.getenv("DB_USER") +DB_PASSWORD = os.getenv("DB_PASSWORD") + +# Connexion sans DB initiale pour lister les bases +@st.cache_data +def get_databases(): + conn = mysql.connector.connect( + host=DB_HOST, + user=DB_USER, + password=DB_PASSWORD + ) + cursor = conn.cursor() + cursor.execute("SHOW DATABASES") + bases = [db[0] for db in cursor.fetchall()] + conn.close() + return bases + +# Connexion avec DB sélectionnée +def connect_to_db(db_name): + return mysql.connector.connect( + host=DB_HOST, + user=DB_USER, + password=DB_PASSWORD, + database=db_name + ) + +# --- Interface principale --- + +base = st.selectbox("Choisir une base de données", get_databases()) +if base: + conn = connect_to_db(base) + cursor = conn.cursor() + + cursor.execute("SHOW TABLES") + tables = [table[0] for table in cursor.fetchall()] + table = st.selectbox("Choisir une table", tables) + + if table: + cursor.execute(f"DESCRIBE {table}") + colonnes = cursor.fetchall() + + # Détection clé primaire + cursor.execute(f"SHOW INDEX FROM {table} WHERE Key_name = 'PRIMARY'") + pk = cursor.fetchone() + primary_key = pk[4] if pk else None + + champ_date_candidates = [col[0] for col in colonnes if "date" in col[1].lower()] + champ_date = st.selectbox("Champ de date", champ_date_candidates) + + nb_mois = st.number_input("Nombre d'insertions mensuelles", 1, 36, 6) + date_depart = st.date_input("Date de départ des insertions", value=datetime.today().date()) + st.subheader("Champs à insérer (hors clé primaire et champ de date)") + champs_choisis = [] + champs_editables = [col for col in colonnes if col[0] != primary_key and col[0] != champ_date] + for col in champs_editables: + if st.checkbox(f"{col[0]} ({col[1]})", value=True): + champs_choisis.append(col[0]) + + with st.form("formulaire_insertion"): + st.markdown("**Valeurs fixes pour les champs cochés**") + valeurs_fixes = {} + for nom in champs_choisis: + val = st.text_input(nom) + valeurs_fixes[nom] = val if val != "" else None + + submit = st.form_submit_button("Insérer") + + try: + cursor = conn.cursor() + insert_count = 0 + + for i in range(nb_mois): + year = date_depart.year + (date_depart.month + i - 1) // 12 + month = (date_depart.month + i - 1) % 12 + 1 + day = min(date_depart.day, 28) + date_cible = datetime(year, month, day).date() + + champs = [champ_date] + list(valeurs_fixes.keys()) + valeurs = [date_cible] + list(valeurs_fixes.values()) + sql = f"INSERT INTO {table} ({', '.join(champs)}) VALUES ({', '.join(['%s'] * len(valeurs))})" + + cursor.execute(sql, valeurs) + insert_count += 1 + + conn.commit() + st.success(f"{insert_count} lignes insérées avec succès dans `{table}`.") + + except Exception as e: + st.error(f"❌ Erreur lors de l’insertion : {e}") + + conn.commit() + st.success(f"{insert_count} lignes insérées avec succès dans `{table}`.") +st.success(f"{insert_count} lignes insérées avec succès.") \ No newline at end of file diff --git a/Backup_Synology/Test_mail.py b/Backup_Synology/Test_mail.py new file mode 100644 index 0000000..7a37988 --- /dev/null +++ b/Backup_Synology/Test_mail.py @@ -0,0 +1,24 @@ +# Programme de test de la BAL alertes_saclay@domo91.fr. +import smtplib +from email.mime.text import MIMEText + +def envoyer_mail(sujet, message, destinataires): + msg = MIMEText(message) + msg['Subject'] = sujet + msg['From'] = 'alertes_saclay@domo91.fr' + msg['To'] = ', '.join(destinataires) + + try: + with smtplib.SMTP_SSL('smtp.mail.ovh.net', 465) as server: + server.login('alertes_saclay@domo91.fr', 'Kdpke674y23Feq^H') + server.sendmail(msg['From'], destinataires, msg.as_string()) + print(f"📧 Mail envoyé à {destinataires}") + except Exception as e: + print(f"Erreur envoi mail : {e}") + +# --- Test d'envoi --- +envoyer_mail( + sujet="🧪 Test d'envoi d'alerte", + message="Ceci est un test de l'envoi d'e-mail via alertes_saclay@domo91.fr.", + destinataires=["services@domo91.fr"] +) diff --git a/Backup_Synology/Tracker.py b/Backup_Synology/Tracker.py new file mode 100644 index 0000000..6d47f1f --- /dev/null +++ b/Backup_Synology/Tracker.py @@ -0,0 +1,106 @@ +# Programme de récupération des adresses de sondes DS18B20 et envoie dans table Sondes.Tracker. +import paho.mqtt.client as mqtt +import mysql.connector +import re # Import de la bibliothèque des expressions régulières + +# Configuration de la base de données MySQL +db_config = { + 'user': 'superviseur', # Remplacez par votre utilisateur MySQL + 'password': 'Bto7Lm_z]m!BFH!*', # Remplacez par votre mot de passe MySQL + 'host': '54.36.188.119', # Adresse de votre serveur MySQL (localhost si en local) + 'database': 'Sondes' # Nom de la base de données MySQL +} + + +def convertir_rom_id_en_hexa(rom_id): + # On découpe la chaîne rom_id en paires de deux caractères + hex_parts = [f"0x{rom_id[i:i + 2]}" for i in range(0, len(rom_id), 2)] + return ",".join(hex_parts) + + +# Connexion à la base de données MySQL +def connect_db(): + return mysql.connector.connect(**db_config) + + +# Fonction pour vérifier si la sonde est déjà présente dans la base +def sonde_deja_presente(rom_id): + conn = connect_db() + cursor = conn.cursor() + try: + # Vérifier si la sonde existe déjà dans la base + cursor.execute("SELECT COUNT(*) FROM Tracker WHERE rom_id = %s", (rom_id,)) + result = cursor.fetchone() + return result[0] > 0 # Si le nombre est supérieur à 0, la sonde est déjà présente + + except mysql.connector.Error as err: + print(f"Erreur MySQL lors de la vérification de la sonde : {err}") + return False + + finally: + cursor.close() + conn.close() + + +# Fonction pour insérer les sondes dans la base de données +def inserer_sonde(rom_id): + if sonde_deja_presente(rom_id): + print(f"Sonde {rom_id} déjà présente dans la base de données. Aucune insertion effectuée.") + return + + conn = connect_db() + cursor = conn.cursor() + try: + # Conversion en hexadécimal + rom_id_hexa = convertir_rom_id_en_hexa(rom_id) + + # Insertion de rom_id et de sa version hexa dans la base + cursor.execute("INSERT INTO Tracker (rom_id, hexa) VALUES (%s, %s)", (rom_id, rom_id_hexa)) + conn.commit() + print(f"Sonde {rom_id} insérée dans la base de données avec son format hexa {rom_id_hexa}.") + + except mysql.connector.Error as err: + print(f"Erreur MySQL : {err}") + + finally: + cursor.close() + conn.close() + + +# Fonction de callback pour gérer les messages MQTT +def on_message(_client, _userdata, message): + payload = message.payload.decode() + print(f"Message reçu : {payload}") + + # Utilisation de re pour extraire les ROM IDs (Sonde [rom_id]) + rom_ids = re.findall(r"[0-9a-fA-F]{16}", payload) # Capturer les IDs de 16 caractères + if rom_ids: + for rom_id in rom_ids: + inserer_sonde(rom_id) + else: + print("Aucun ROM ID trouvé dans le message.") + + +# Configuration du client MQTT +mqtt_broker = "46.105.92.116" +mqtt_port = 1883 # Vérifiez si votre broker utilise un autre port +mqtt_user = "Bwps" +mqtt_password = "scJ5ACj2keRfI^" +mqtt_topic = "Tracker/sondes" + +client = mqtt.Client() + +# Authentification MQTT +client.username_pw_set(mqtt_user, mqtt_password) + +# Configuration du callback pour les messages MQTT +client.on_message = on_message + +# Connexion au broker MQTT +client.connect(mqtt_broker, mqtt_port, 60) + +# Souscription au topic Tracker/sondes +client.subscribe(mqtt_topic) + +# Démarrer la boucle MQTT +client.loop_forever() diff --git a/Backup_Synology/domo91.py b/Backup_Synology/domo91.py new file mode 100644 index 0000000..6df5cd9 --- /dev/null +++ b/Backup_Synology/domo91.py @@ -0,0 +1,331 @@ +# Application Gestion de sondes +import streamlit as st +import mysql.connector +import pandas as pd +from datetime import date +import matplotlib.pyplot as plt +import matplotlib.dates as mdates +from fpdf import FPDF +import os +import random + +st.set_page_config(page_title="Domo91 - Surveillance", layout="wide") +st.title("📡 Supervision Températures") + +# --- Configuration base de données --- +db_config = { + "host": "54.36.188.119", + "user": "michel", + "password": "#SO2&1nf%mZ@jfh", + "database": "Sondes" +} +# --- Fonction de génération PDF --- +def generer_pdf(site, date_str): + st.info(f"Génération du rapport PDF pour {site} à la date {date_str}") + try: + conn = mysql.connector.connect(**db_config) + cursor = conn.cursor(dictionary=True) + + cursor.execute(f"SELECT Sonde, Date, Temperature FROM `{site}` WHERE DATE(Date) = %s ORDER BY Sonde, Date", (date_str,)) + rows = cursor.fetchall() + df = pd.DataFrame(rows) + df["Heure"] = pd.to_datetime(df["Date"]).dt.strftime("%H:%M") + + releves = {} + for sonde in df["Sonde"].unique(): + df_sonde = df[df["Sonde"] == sonde] + releves[sonde] = list(zip(df_sonde["Heure"], df_sonde["Temperature"])) + + table_alertes = f"Alertes_{site}" + cursor.execute(f"SELECT Sonde, Debut_defaut, Status FROM {table_alertes} WHERE DATE(Debut_defaut) = %s", (date_str,)) + alertes = cursor.fetchall() + + cursor.close() + conn.close() + + 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.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) + self.set_font("Arial", "", 10) + for heure, temp in mesures: + self.cell(0, 6, f"{heure} - {temp} °C", ln=1) + self.ln(2) + + 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) + + pdf = RapportPDF() + 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) # 🔧 Crée le dossier si absent + 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" + ) + + except Exception as e: + st.error(f"Erreur lors de la génération du PDF : {e}") +# --- Initialisation session --- +if "authenticated" not in st.session_state: + st.session_state["authenticated"] = False + st.session_state["role"] = None + st.session_state["lieu_autorise"] = None + +# --- Sidebar (connexion + bouton PDF) --- +with st.sidebar: + st.header("🔐 Connexion") + if not st.session_state.get("authenticated"): + login = st.text_input("Nom d'utilisateur") + password = st.text_input("Mot de passe", type="password") + if st.button("Se connecter"): + try: + conn = mysql.connector.connect(**db_config) + cursor = conn.cursor(dictionary=True) + cursor.execute("SELECT * FROM MotsDePasse WHERE utilisateur = %s", (login,)) + result = cursor.fetchone() + if result and result["mot_de_passe"] == password: + st.session_state["authenticated"] = True + st.session_state["role"] = result["role"] + st.session_state["lieu_autorise"] = result["Lieu"] + st.success(f"Connecté comme {result['role']} ({result['Lieu']})") + else: + st.error("Identifiants invalides") + cursor.close() + conn.close() + except Exception as e: + st.error(f"Erreur lors de la connexion à la base : {e}") + else: + st.success(f"Connecté ({st.session_state['role']})") + if st.button("🔓 Déconnexion"): + st.session_state["authenticated"] = False + st.session_state["role"] = None + st.session_state["lieu_autorise"] = None + st.rerun() + + st.markdown("---") + st.subheader("📄 Rapport PDF") + if "selected_date" in st.session_state: + if st.button("📥 Télécharger l’état du jour (PDF)"): + site = st.session_state["lieu_autorise"] + date_val = st.session_state["selected_date"].strftime("%Y-%m-%d") + generer_pdf(site, date_val) + else: + st.info("Sélectionnez une date pour activer la génération PDF.") + +# --- CONTENU PRINCIPAL SI AUTHENTIFIÉ --- +if st.session_state["authenticated"]: + st.markdown("## Sélection du site et de la date") + try: + conn = mysql.connector.connect(**db_config) + cursor = conn.cursor(dictionary=True) + sites_possibles = ["Saclay", "Meudon"] + if st.session_state["role"] == "superviseur": + site_selectionne = st.selectbox("📍 Choisissez un site :", sites_possibles) + else: + site_selectionne = st.session_state["lieu_autorise"] + st.info(f"Site imposé : {site_selectionne}") + + + selected_date = st.date_input("📅 Date du relevé", value=date.today()) + st.session_state["selected_date"] = selected_date + + cursor.execute( + f"SELECT * FROM `{site_selectionne}` WHERE DATE(Date) = %s ORDER BY Sonde, Date", + (selected_date.strftime("%Y-%m-%d"),) + ) + rows = cursor.fetchall() + if rows: + df = pd.DataFrame(rows) + df["Date"] = pd.to_datetime(df["Date"]) + sondes = sorted(df["Sonde"].unique()) + sonde_choisie = st.selectbox("🧪 Choisissez une sonde :", sondes) + df_sonde = df[df["Sonde"] == sonde_choisie] + +# Ajouter une colonne Heure pour faciliter les filtres + df_sonde.loc[:, "Heure"] = df_sonde["Date"].dt.hour + +# Filtrage par tranche horaire + tranche = st.radio("🕒 Tranche horaire :", + ["Toute la journée", "Matin (6h-12h)", "Après-midi (12h-18h)", "Nuit (18h-6h)"]) + + if tranche == "Matin (6h-12h)": + df_sonde = df_sonde[(df_sonde["Heure"] >= 6) & (df_sonde["Heure"] < 12)] + elif tranche == "Après-midi (12h-18h)": + df_sonde = df_sonde[(df_sonde["Heure"] >= 12) & (df_sonde["Heure"] < 18)] + elif tranche == "Nuit (18h-6h)": + df_sonde = df_sonde[(df_sonde["Heure"] >= 18) | (df_sonde["Heure"] < 6)] + df_sonde = df_sonde.copy() + + cursor.execute("SELECT Temp_Max FROM Chambres_froides WHERE Lieu = %s AND Sonde = %s", (site_selectionne, sonde_choisie)) + seuil = cursor.fetchone() + seuil_temp = seuil["Temp_Max"] if seuil else 10 + + st.subheader("📊 Tableau des relevés") + df_filtré = df_sonde.copy() + df_filtré = df_filtré.drop(columns="Id", errors="ignore") + + + def surlignage_temp(val): + try: + if float(val) > seuil_temp: + return "color: red; font-weight: bold" + except: + pass + return "" + + +# Appliquer le style uniquement à la colonne "Temperature" + + styled_df = df_filtré.style.applymap(surlignage_temp, subset=["Temperature"]) + + st.dataframe(styled_df, use_container_width=True) + + st.subheader("📈 Évolution de la température") + fig, ax = plt.subplots(figsize=(10, 4)) + ax.plot(df_filtré["Date"], df_filtré["Temperature"], marker='o', label="Température") + ax.axhline(seuil_temp, color='red', linestyle='--', label=f"Seuil {seuil_temp}°C") + ax.set_xlabel("Heure") + ax.set_ylabel("Température (°C)") + ax.set_title(f"{sonde_choisie} - {selected_date.strftime('%d/%m/%Y')}") + ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M')) + ax.legend() + st.pyplot(fig) +# --- Affichage automatique des alertes non acquittées --- + try: + conn = mysql.connector.connect(**db_config) + cursor = conn.cursor(dictionary=True) + + table_alertes = f"Alertes_{site_selectionne}" + cursor.execute( + f"SELECT Sonde, Debut_defaut, Status FROM `{table_alertes}` WHERE Status != 'Acquitté' 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}") + + except Exception as e: + st.error(f"Erreur MySQL : {e}") +if st.session_state["role"] == "superviseur": + with st.expander("➕ Ajouter une nouvelle chambre froide", expanded=False): + with st.form("ajout_sonde"): + nouvelle_sonde = st.text_input("Nom de la sonde") + temp_max = st.number_input("Température maximale autorisée (°C)", value=4) + etat_on = st.checkbox("État actif (ON)", value=True) + + submitted = st.form_submit_button("✅ Ajouter") + if submitted: + try: + conn_add = mysql.connector.connect(**db_config) + cursor_add = conn_add.cursor() + + cursor_add.execute( + "INSERT INTO Chambres_froides (Lieu, Sonde, Temp_Max, Etat) VALUES (%s, %s, %s, %s)", + (site_selectionne, nouvelle_sonde, temp_max, "ON" if etat_on else "OFF") + ) + conn_add.commit() + cursor_add.close() + conn_add.close() + + st.success(f"Sonde '{nouvelle_sonde}' ajoutée avec succès au site {site_selectionne} 🎉") + + # Refresh immédiat + st.session_state["refresh_admin"] = random.randint(1000, 9999) + + except Exception as e: + st.error(f"Erreur lors de l'ajout : {e}") + with st.expander("🛠️ Gestion des chambres froides (administrateur)", expanded=True): + + # Bouton d'actualisation + if st.button("🔄 Actualiser la liste"): + st.session_state["refresh_admin"] = random.randint(0, 9999) # Force le rerun + + try: + conn_admin = mysql.connector.connect(**db_config) + cursor_admin = conn_admin.cursor(dictionary=True) + + cursor_admin.execute("SELECT * FROM Chambres_froides WHERE Lieu = %s", (site_selectionne,)) + chambres = cursor_admin.fetchall() + + if not chambres: + st.warning("Aucune chambre froide pour ce site.") + else: + for chambre in chambres: + col1, col2, col3 = st.columns([3, 1, 2]) + with col1: + st.markdown(f"**{chambre['Sonde']}**") + + with col2: + etat = st.checkbox("ON", value=(chambre["Etat"] == "ON"), + key=f"etat_{chambre['Id']}_{st.session_state.get('refresh_admin', 0)}") + new_etat = "ON" if etat else "OFF" + + with col3: + temp_max = chambre["Temp_Max"] + moins, val, plus = st.columns([1, 2, 1]) + with moins: + if st.button("➖", key=f"moins_{chambre['Id']}"): + temp_max -= 1 + with val: + st.markdown(f"
{temp_max}°C
", + unsafe_allow_html=True) + with plus: + if st.button("➕", key=f"plus_{chambre['Id']}"): + temp_max += 1 + + if new_etat != chambre["Etat"] or temp_max != chambre["Temp_Max"]: + cursor_admin.execute( + "UPDATE Chambres_froides SET Etat = %s, Temp_Max = %s WHERE Id = %s", + (new_etat, temp_max, chambre["Id"]) + ) + conn_admin.commit() + st.success(f"{chambre['Sonde']} mise à jour") + + cursor_admin.close() + conn_admin.close() + + except Exception as e: + st.error(f"Erreur SQL (admin) : {e}") + + diff --git a/Chaufferie.py b/Chaufferie.py new file mode 100644 index 0000000..73eab00 --- /dev/null +++ b/Chaufferie.py @@ -0,0 +1,30 @@ +import paho.mqtt.client as mqtt +import mysql.connector + +# Configuration de la connexion MySQL +mydb = mysql.connector.connect( + host="54.36.188.119", + user="michel", + password="#SO2&1nf%mZ@jfh", + database="Sondes" +) + +# Fonction de callback quand un message est reçu +def on_message(_client, _userdata, msg): + print(f"Message reçu sur {msg.topic}: {msg.payload.decode()}") + cursor = mydb.cursor() + frigo_name = msg.topic.split('/')[-1] # Prend la dernière partie après le "/" + sql = "INSERT INTO Chaufferie (Sonde, Temperature) VALUES (%s, %s)" + val = (frigo_name, msg.payload.decode()) + cursor.execute(sql, val) + mydb.commit() + +# Configuration du client MQTT +client = mqtt.Client() +client.username_pw_set("Bwps", "scJ5ACj2keRfI^") +client.on_message = on_message + +client.connect("54.36.188.119", 1883, 60) +client.subscribe("Module_01/#") # S'abonner à tous les topics commençant par Saclay + +client.loop_forever() # Rester connecté en continu pour écouter les messages diff --git a/Purge_Alertes_saclay.py b/Purge_Alertes_saclay.py new file mode 100644 index 0000000..83f89e2 --- /dev/null +++ b/Purge_Alertes_saclay.py @@ -0,0 +1,18 @@ +# Purge de la table Sondes.Alertes_Saclay. +import mysql.connector + +config = { + "host": "54.36.188.119", + "user": "michel", + "password": "#SO2&1nf%mZ@jfh", + "database": "Sondes" +} + +conn = mysql.connector.connect(**config) +cursor = conn.cursor() +cursor.execute("DELETE FROM Alertes_Saclay WHERE Debut_defaut < NOW() - INTERVAL 7 DAY") +conn.commit() +cursor.close() +conn.close() + +print("✅ Alertes de plus de 7 jours supprimées.") diff --git a/Telegram_sondes.py b/Telegram_sondes.py new file mode 100644 index 0000000..3077d92 --- /dev/null +++ b/Telegram_sondes.py @@ -0,0 +1,324 @@ +# Gestion des chambres froides & alertes Telegram +import requests +import mysql.connector +from datetime import datetime, timedelta +import time +import sys +import os +import schedule + +def connect_db(): + return mysql.connector.connect( + host="54.36.188.119", + user="michel", + password="#SO2&1nf%mZ@jfh", + database="Sondes" + ) + +def envoi_etat_quotidien(cursor, site): + token = "8128378340:AAF2sO3gaH1XpMNya_pEslzerqokoCiFRGs" + chat_id = get_chat_id(cursor, site) + etat_sondes(cursor, site, chat_id, token) + print(f"[INFO] État des sondes envoyé pour le site {site}.") + +def get_active_sondes(cursor, site): + query = "SELECT Sonde, Temp_Max FROM Chambres_froides WHERE Lieu = %s AND Etat = 'On';" + cursor.execute(query, (site,)) + result = cursor.fetchall() + return {row[0]: float(row[1]) for row in result} + + +def check_temperature_limits(cursor, table_historique, sonde, limite, duree=30): + temps_limite = datetime.now() - timedelta(minutes=duree) + query = f""" + SELECT Temperature + FROM {table_historique} + WHERE Sonde = %s AND Date >= %s + ORDER BY Date DESC LIMIT 6; + """ + cursor.execute(query, (sonde, temps_limite)) + result = cursor.fetchall() + if len(result) == 6 and all(float(temp[0]) > limite for temp in result): + return True, float(result[0][0]) + return False, None + +def simulate_alert(db, cursor, site, sonde, chat_id, token): + table_alertes = f"Alertes_{site}" + print(f"[TEST] tentative d'insertion de sonde : {sonde} dans table {table_alertes}") + + try: + query = f""" + INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status) + VALUES (%s, NOW(), 'test') + ON DUPLICATE KEY UPDATE Debut_defaut = NOW(), Status = 'test'; + """ + cursor.execute(query, (sonde,)) + db.commit() + print(f"[TEST] insertion ou mise à jour réussie pour {sonde}.") + except Exception as e: + print(f"[ERREUR] lors de l'insertion test : {e}") + + message = f"⚠️ TEST ALERTE : Simulation d'une alerte pour la sonde {sonde}." + url = f"https://api.telegram.org/bot{token}/sendMessage" + try: + requests.get(url, params={'chat_id': chat_id, 'text': message}) + except Exception as e: + print(f"[ERREUR] lors de l'envoi Telegram : {e}") + +def create_alert(db, cursor, table_alertes, sonde, temperature): + query = f""" + INSERT INTO {table_alertes} (Sonde, Debut_defaut, Status) + VALUES (%s, NOW(), 'en cours'); + """ + cursor.execute(query, (sonde,)) + send_telegram_message(sonde, temperature) + print(f"Alerte créée pour la sonde {sonde}") + db.commit() + +def resolve_alert(cursor, table_alertes, sonde): + query = f""" + UPDATE {table_alertes} + SET Status = 'résolu' + WHERE Sonde = %s AND Status = 'en cours'; + """ + cursor.execute(query, (sonde,)) + print(f"Alerte résolue pour la sonde {sonde}") + +def acquitter_alerte(cursor, site, sonde, chat_id, token): + table_alertes = f"Alertes_{site}" + query = f""" + UPDATE {table_alertes} + SET Status = 'acquittée' + WHERE Sonde = %s AND Status IN ('en cours', 'test'); + """ + cursor.execute(query, (sonde,)) + lignes_modifiees = cursor.rowcount + + if lignes_modifiees > 0: + message = f"✅ Alerte acquittée pour la sonde {sonde} par commande Telegram." + else: + message = f"ℹ️ Aucune alerte active à acquitter pour la sonde {sonde}." + + url = f"https://api.telegram.org/bot{token}/sendMessage" + try: + requests.get(url, params={'chat_id': chat_id, 'text': message}) + except Exception as e: + print(f"[ERREUR] envoi message Telegram : {e}") + +def send_telegram_message(sonde, temperature): + token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE" + chat_id = "-1002442631825" + message = f"⚠️ Alerte température : La sonde {sonde} dépasse la limite avec une température de {temperature}°C." + url = f"https://api.telegram.org/bot{token}/sendMessage" + params = {'chat_id': chat_id, 'text': message} + try: + response = requests.get(url, params=params) + if response.status_code == 200: + print(f"Message envoyé via Telegram pour la sonde {sonde}.") + else: + print(f"Erreur lors de l'envoi du message Telegram : {response.status_code}") + except Exception as e: + print(f"Erreur lors de l'envoi du message Telegram : {e}") + + +def get_chat_id(cursor, site): + cursor.execute("SELECT Chat_ID FROM Sites WHERE Nom = %s;", (site,)) + result = cursor.fetchone() + if result: + return result[0] + else: + print(f"Aucun Chat_ID trouvé pour le site {site}") + return None + +def passer_en_maintenance(cursor, site, sonde, chat_id, token): + try: + query = """ + UPDATE Chambres_froides + SET Etat = 'Off' + WHERE Lieu = %s AND Sonde = %s; + """ + cursor.execute(query, (site, sonde)) + lignes_modifiees = cursor.rowcount + + if lignes_modifiees > 0: + message = f"🛠️ La sonde {sonde} a été passée en mode maintenance (OFF)." + else: + message = f"⚠️ Sonde {sonde} introuvable pour le site {site}." + + url = f"https://api.telegram.org/bot{token}/sendMessage" + requests.get(url, params={'chat_id': chat_id, 'text': message}) + + except Exception as e: + print(f"[ERREUR] lors du passage en maintenance : {e}") + +def reactiver_sonde(cursor, site, sonde, chat_id, token): + try: + query = """ + UPDATE Chambres_froides + SET Etat = 'On' + WHERE Lieu = %s AND Sonde = %s; + """ + cursor.execute(query, (site, sonde)) + lignes_modifiees = cursor.rowcount + + if lignes_modifiees > 0: + message = f"✅ La sonde {sonde} a été réactivée (ON)." + else: + message = f"⚠️ Sonde {sonde} introuvable pour le site {site}." + + url = f"https://api.telegram.org/bot{token}/sendMessage" + requests.get(url, params={'chat_id': chat_id, 'text': message}) + + except Exception as e: + print(f"[ERREUR] lors de la réactivation : {e}") + +def etat_sondes(cursor, site, chat_id, token): + query = "SELECT Sonde, Etat FROM Chambres_froides WHERE Lieu = %s ORDER BY Sonde;" + cursor.execute(query, (site,)) + result = cursor.fetchall() + + message = f"📊 État des sondes - {site} :\n" + for sonde, etat in result: + symbole = "🟢" if etat.upper() == "ON" else "🔴" + message += f"{symbole} {sonde} ({etat.upper()})\n" + + url = f"https://api.telegram.org/bot{token}/sendMessage" + requests.get(url, params={'chat_id': chat_id, 'text': message}) + +def monitor_temperatures_simple(site, db, cursor): + table_historique = site + table_alertes = f"Alertes_{site}" + sondes = get_active_sondes(cursor, site) + print(f"[MONITORING] Sondes actives pour {site} : {sondes}") + + for sonde, limite in sondes.items(): + alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite) + if alert_needed: + create_alert(db, cursor, table_alertes, sonde, temperature) + else: + resolve_alert(cursor, table_alertes, sonde) + + db.commit() + print("[MONITORING] Vérification des sondes terminée.") + +def monitor_temperatures(site): + db = connect_db() + cursor = db.cursor() + + table_historique = site # Ex: Saclay + table_alertes = f"Alertes_{site}" # Ex: Alertes_Saclay + + sondes = get_active_sondes(cursor, site) + print(f"Sondes actives pour le site {site} :", sondes) + + for sonde, limite in sondes.items(): + alert_needed, temperature = check_temperature_limits(cursor, table_historique, sonde, limite) + if alert_needed: + create_alert(db, cursor, table_alertes, sonde, temperature) + else: + resolve_alert(cursor, table_alertes, sonde) + + db.commit() + listen_for_commands(db, cursor, site) + cursor.close() + db.close() + +def listen_for_commands(db, cursor, site): + token = "5714323406:AAGSj9jrfBHbfxubz3ooabPEizI8aBOLnvE" + chat_id = get_chat_id(cursor, site) + offset_file = os.path.join(os.path.dirname(__file__), f"last_update_id_{site}.txt") + + try: + with open(offset_file, 'r') as f: + last_update_id = int(f.read().strip()) + except FileNotFoundError: + last_update_id = None + + url = f"https://api.telegram.org/bot{token}/getUpdates" + if last_update_id is not None: + url += f"?offset={last_update_id + 1}" + + try: + response = requests.get(url) + data = response.json() + + if "result" in data: + for update in data["result"]: + update_id = update["update_id"] + + if "message" in update: + message = update["message"]["text"] + print(f"[CMD] Message reçu : {message}") + + if message.lower().startswith("/etat"): + etat_sondes(cursor, site, chat_id, token) + + elif message.lower().startswith("/acquitter"): + parts = message.strip().split(" ", 1) + if len(parts) == 2 and parts[1].strip(): + sonde = parts[1].strip() + acquitter_alerte(cursor, site, sonde, chat_id, token) + db.commit() + else: + erreur_msg = "❌ Utilisation incorrecte. Format attendu : /acquitter " + requests.get(f"https://api.telegram.org/bot{token}/sendMessage", + params={'chat_id': chat_id, 'text': erreur_msg}) + elif message.lower().startswith("/maintenance"): + parts = message.strip().split(" ", 1) + if len(parts) == 2 and parts[1].strip(): + sonde = parts[1].strip() + passer_en_maintenance(cursor, site, sonde, chat_id, token) + db.commit() + else: + erreur_msg = "❌ Utilisation incorrecte. Format attendu : /maintenance " + requests.get(f"https://api.telegram.org/bot{token}/sendMessage", + params={'chat_id': chat_id, 'text': erreur_msg}) + elif message.lower().startswith("/reactiver"): + parts = message.strip().split(" ", 1) + if len(parts) == 2 and parts[1].strip(): + sonde = parts[1].strip() + reactiver_sonde(cursor, site, sonde, chat_id, token) + db.commit() + else: + erreur_msg = "❌ Utilisation incorrecte. Format attendu : /reactiver " + requests.get(f"https://api.telegram.org/bot{token}/sendMessage", + params={'chat_id': chat_id, 'text': erreur_msg}) + elif message.lower().startswith("/test"): + parts = message.strip().split(" ", 1) + if len(parts) == 2 and parts[1].strip(): + sonde = parts[1].strip() + simulate_alert(db, cursor, site, sonde, chat_id, token) + else: + erreur_msg = "❌ Utilisation incorrecte. Format attendu : /test " + requests.get(f"https://api.telegram.org/bot{token}/sendMessage", + params={'chat_id': chat_id, 'text': erreur_msg}) + + with open(offset_file, 'w') as f: + f.write(str(update_id)) + + except Exception as e: + print(f"Erreur lors de la lecture des commandes Telegram : {e}") + + +def main(): + site = sys.argv[1] if len(sys.argv) > 1 else "Saclay" + db = connect_db() + cursor = db.cursor() + + # ✅ Planification : tous les jours à 07:00 → état des sondes + schedule.every().day.at("07:00").do(envoi_etat_quotidien, cursor=cursor, site=site) + + # ✅ Planification : toutes les 2m30 → surveillance + schedule.every(2).minutes.do(monitor_temperatures_simple, site=site, db=db, cursor=cursor) + + try: + while True: + schedule.run_pending() + listen_for_commands(db, cursor, site) + time.sleep(2) # petite pause pour ne pas surcharger Telegram + finally: + cursor.close() + db.close() + +if __name__ == "__main__": + main() diff --git a/logs_analyse.py b/logs_analyse.py new file mode 100644 index 0000000..5630e30 --- /dev/null +++ b/logs_analyse.py @@ -0,0 +1,39 @@ +import streamlit as st +import pandas as pd +import matplotlib.pyplot as plt + +# --- Chargement des données --- +try: + df = pd.read_csv("/home/debian/travail/logs_monitor.csv", sep=";", parse_dates=["Date"]) +except FileNotFoundError: + st.error("📂 Le fichier de log n'a pas été trouvé.") + st.stop() + +st.title("🧾 Analyse des scans Monitor.py") + +# --- Filtres --- +df["Date_str"] = df["Date"].dt.date +dates_dispo = sorted(df["Date_str"].unique(), reverse=True) +date_selection = st.selectbox("📅 Sélectionnez une date :", dates_dispo) + +lieux = sorted(df["Lieu"].unique()) +lieu_selection = st.selectbox("📍 Site :", lieux) + +df_filtré = df[(df["Date_str"] == date_selection) & (df["Lieu"] == lieu_selection)] + +sondes = sorted(df_filtré["Sonde"].unique()) +sonde_selection = st.selectbox("🧪 Sonde :", sondes) + +df_sonde = df_filtré[df_filtré["Sonde"] == sonde_selection] + +# --- Graphique température --- +fig, ax = plt.subplots(figsize=(10, 4)) +ax.plot(df_sonde["Date"], df_sonde["Température"], marker='o') +ax.set_title(f"Évolution de la température - {sonde_selection}") +ax.set_xlabel("Heure") +ax.set_ylabel("Température (°C)") +st.pyplot(fig) + +# --- Tableau complet du jour/sonde sélectionnés --- +st.markdown("### 📋 Détail des scans") +st.dataframe(df_sonde[["Date", "Sonde", "Température", "Seuil", "État"]], use_container_width=True) diff --git a/supervisor_watchdog.py b/supervisor_watchdog.py new file mode 100644 index 0000000..76a7834 --- /dev/null +++ b/supervisor_watchdog.py @@ -0,0 +1,47 @@ +# Controle des services supervisor envoi en cas de disfonction et tous les jours à sept heures +# a faire tourner avec crontb -e en sudo +# */30 * * * * /home/debian/travail/myenv/bin/python3 /home/debian/travail/Scripts/supervisor_watchdog.py +import subprocess +import smtplib +from email.mime.text import MIMEText +from datetime import datetime + +heure_actuelle = datetime.now().strftime("%H:%M") +etat_services = [] +anomalies = [] + +try: + output = subprocess.check_output("/usr/bin/supervisorctl status", shell=True, text=True) + for line in output.splitlines(): + parts = line.split() + if len(parts) >= 2: + nom, statut = parts[0], parts[1] + etat_services.append(f"{nom} ➤ {statut}") + if statut != "RUNNING": + anomalies.append(f"{nom} ➤ {statut}") +except Exception as e: + etat_services.append("❌ Impossible d'exécuter supervisorctl") + anomalies.append(f"Erreur : {e}") + +# Déclenchement mail si anomalie ou à 07:00 +envoyer_mail = bool(anomalies) or heure_actuelle == "07:00" + +if envoyer_mail: + sujet = "⚠️ Alerte Supervisor" if anomalies else "✅ Rapport quotidien Supervisor" + intro = "🛑 Les services suivants ne sont pas en RUNNING :" if anomalies else "✅ Tous les services supervisés sont en RUNNING." + contenu = f"{intro}\n\n" + "\n".join(etat_services) + + msg = MIMEText(contenu) + msg["Subject"] = sujet + msg["From"] = "alertes_saclay@domo91.fr" + msg["To"] = "services@domo91.fr" + + try: + with smtplib.SMTP_SSL("smtp.mail.ovh.net", 465) as server: + server.login("alertes_saclay@domo91.fr", "Kdpke674y23Feq^H") + server.sendmail(msg["From"], [msg["To"]], msg.as_string()) + print("📧 Mail envoyé.") + except Exception as e: + print(f"Erreur envoi mail : {e}") +else: + print("🕖 Aucun mail envoyé (tout est OK et ce n’est pas l’heure du rapport).")