From 31588a034dc91f3cabc4a5c6bb23d4adc7a76b80 Mon Sep 17 00:00:00 2001 From: Michel Date: Thu, 10 Apr 2025 16:10:32 +0200 Subject: [PATCH] Ajout des fichiers prod depuis develop --- Cuisine_meudon.py | 30 +++++ Cuisine_saclay.py | 30 +++++ Monitor.py | 129 ++++++++++++++++++ Streamlit.py | 237 +++++++++++++++++++++++++++++++++ Telegram_sondes.py | 323 +++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 749 insertions(+) create mode 100644 Cuisine_meudon.py create mode 100644 Cuisine_saclay.py create mode 100644 Monitor.py create mode 100644 Streamlit.py create mode 100644 Telegram_sondes.py diff --git a/Cuisine_meudon.py b/Cuisine_meudon.py new file mode 100644 index 0000000..e8c1b05 --- /dev/null +++ b/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/Cuisine_saclay.py b/Cuisine_saclay.py new file mode 100644 index 0000000..4e68428 --- /dev/null +++ b/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/Monitor.py b/Monitor.py new file mode 100644 index 0000000..0a72774 --- /dev/null +++ b/Monitor.py @@ -0,0 +1,129 @@ +#!/home/debian/travail/myenv/bin/python +# 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/Streamlit.py b/Streamlit.py new file mode 100644 index 0000000..0c7fa0e --- /dev/null +++ b/Streamlit.py @@ -0,0 +1,237 @@ +# Application Streamlit avec coloration rouge des températures dépassant les seuils dans logs + +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 + +st.set_page_config(page_title="Domo91 - Surveillance", layout="wide") +st.title("📡 Supervision Températures Multisites") + +# --- Configuration base de données --- +db_config = { + "host": "54.36.188.119", + "user": "michel", + "password": "#SO2&1nf%mZ@jfh", + "database": "Sondes" +} + +if "authenticated" not in st.session_state: + st.session_state["authenticated"] = False + st.session_state["role"] = None + st.session_state["lieu_autorise"] = None + +# --- Accès aux logs dès connexion superviseur --- +if st.session_state.get("authenticated") and st.session_state["role"] == "superviseur": + st.markdown("### 🔍 Accès à l’analyse des relevés") + if st.button("🧾 Analyse des logs Monitor.py"): + st.session_state["page"] = "analyse_logs" + st.rerun() + +# --- Analyse logs si page active --- +if st.session_state.get("page") == "analyse_logs": + st.title("🧾 Analyse des notifications de relevés") + try: + df_logs = pd.read_csv("/home/debian/travail/logs_monitor.csv", sep=";", parse_dates=["Date"]) + df_logs["Date_str"] = df_logs["Date"].dt.date + dates_dispo = sorted(df_logs["Date_str"].unique(), reverse=True) + date_selection = st.selectbox("📅 Sélectionnez une date :", dates_dispo) + lieux = sorted(df_logs["Lieu"].unique()) + lieu_selection = st.selectbox("📍 Site :", lieux) + df_filtré = df_logs[(df_logs["Date_str"] == date_selection) & (df_logs["Lieu"] == lieu_selection)] + sondes = sorted(df_filtré["Sonde"].unique()) + sonde_selection = st.selectbox("🧪 Sonde :", sondes) + df_sonde = df_filtré[df_filtré["Sonde"] == sonde_selection].copy() + + st.subheader(f"📈 Évolution de la température - {sonde_selection}") + fig, ax = plt.subplots(figsize=(10, 4)) + ax.plot(df_sonde["Date"], df_sonde["Température"], marker='o') + ax.set_title(f"{sonde_selection} - {date_selection}") + ax.set_xlabel("Heure") + ax.set_ylabel("Température (°C)") + ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M')) + st.pyplot(fig) + + st.subheader("📋 Détail des relevés") + + # Coloration conditionnelle des températures > seuil + df_sonde["Depassement"] = df_sonde["Température"] > df_sonde["Seuil"] + st.dataframe(df_sonde.style.apply( + lambda row: [ + 'background-color: red; color: white' if row["Depassement"] and col == "Température" else '' + for col in df_sonde.columns + ], axis=1 + ), use_container_width=True) + + st.markdown("---") + if st.button("⬅️ Retour à l'accueil"): + st.session_state["page"] = None + st.rerun() + + except Exception as e: + st.error(f"Erreur lecture logs : {e}") + st.stop() + + +with st.sidebar: + st.markdown("# 🌡️ **Domo91**") + st.markdown("Monitoring chambres froides industrielles") + st.header("🔐 Connexion") + if not st.session_state["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() + +# --- Interface principale +if st.session_state["authenticated"]: + 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()) + 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].copy() + df_sonde["Heure"] = df_sonde["Date"].dt.hour + + # 🕓 Filtres horaires + st.markdown("### 🕒 Filtrer par moment de la journée") + col1, col2, col3 = st.columns(3) + filtre_matin = col1.checkbox("Matin (06h-12h)", value=True) + filtre_apresmidi = col2.checkbox("Après-midi (12h-18h)", value=True) + filtre_nuit = col3.checkbox("Nuit (18h-06h)", value=True) + + # Construction du filtre combiné + filtres = [] + if filtre_matin: + filtres.append(df_sonde["Heure"].between(6, 11)) + if filtre_apresmidi: + filtres.append(df_sonde["Heure"].between(12, 17)) + if filtre_nuit: + filtres.append((df_sonde["Heure"] >= 18) | (df_sonde["Heure"] < 6)) + + if filtres: + filtre_combiné = filtres[0] + for f in filtres[1:]: + filtre_combiné |= f + df_sonde = df_sonde[filtre_combiné] + 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.dataframe(df_sonde, use_container_width=True) + st.subheader("📈 Évolution de la température") + fig, ax = plt.subplots(figsize=(10, 4)) + ax.plot(df_sonde["Date"], df_sonde["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) + else: + st.warning("Aucune donnée trouvée pour cette date.") + + # --- Alertes et bouton vers analyse logs --- + st.markdown("---") + st.subheader("🚨 Alertes de température") + if st.session_state["role"] == "superviseur": + if st.button("🧾 Voir les notifications relevées dans Monitor"): + st.session_state["page"] = "analyse_logs" + st.rerun() + + table_alertes = f"Alertes_{site_selectionne}" + voir_toutes = False + if st.session_state["role"] == "superviseur": + voir_toutes = st.toggle("Afficher toutes les alertes (y compris acquittées)", value=False) + if voir_toutes: + cursor.execute(f"SELECT * FROM {table_alertes} ORDER BY Debut_defaut DESC") + else: + cursor.execute(f"SELECT * FROM {table_alertes} WHERE Status = 'En cours' ORDER BY Debut_defaut DESC") + alertes = cursor.fetchall() + if alertes: + for alerte in alertes: + cols = st.columns([3, 3, 2, 2, 2]) + cols[0].markdown(f"**Sonde :** {alerte['Sonde']}") + cols[1].markdown(f"**Début :** {alerte['Debut_defaut'].strftime('%Y-%m-%d %H:%M')}") + cols[2].markdown(f"**Statut :** {alerte['Status']}") + if st.session_state["role"] == "superviseur" and alerte['Status'] == 'En cours': + key_btn = f"acq_{alerte['Id']}" + if cols[4].button("✅ Acquitter", key=key_btn): + cursor.execute(f"UPDATE {table_alertes} SET Status = 'Acquitté' WHERE Id = %s", (alerte['Id'],)) + conn.commit() + st.success(f"Alerte acquittée pour {alerte['Sonde']}") + st.rerun() + else: + st.info("✅ Aucune alerte en cours.") + + # --- Interface admin seuils / ON-OFF --- + if st.session_state["role"] == "superviseur": + st.markdown("---") + st.subheader("🛠️ Paramètres des sondes") + cursor.execute("SELECT * FROM Chambres_froides WHERE Lieu = %s", (site_selectionne,)) + sondes_info = cursor.fetchall() + if sondes_info: + for sonde in sondes_info: + cols = st.columns([3, 2, 3]) + cols[0].markdown(f"**{sonde['Sonde']}**") + etat_key = f"etat_{sonde['Id']}" + seuil_key = f"seuil_{sonde['Id']}" + etat_actuel = sonde["Etat"] == "ON" + new_etat = cols[1].checkbox("Actif", value=etat_actuel, key=etat_key) + new_seuil = cols[2].number_input("Seuil Max", min_value=-30.0, max_value=30.0, value=float(sonde["Temp_Max"]), step=0.5, key=seuil_key) + sonde["_new_etat"] = "ON" if new_etat else "OFF" + sonde["_new_seuil"] = new_seuil + if st.button("💾 Enregistrer les modifications"): + try: + for sonde in sondes_info: + cursor.execute("UPDATE Chambres_froides SET Etat = %s, Temp_Max = %s WHERE Id = %s", (sonde["_new_etat"], sonde["_new_seuil"], sonde["Id"])) + conn.commit() + st.success("✅ Modifications enregistrées.") + st.rerun() + except Exception as e: + st.error(f"Erreur lors de la mise à jour : {e}") + + cursor.close() + conn.close() + + except Exception as e: + st.error(f"Erreur MySQL : {e}") \ No newline at end of file diff --git a/Telegram_sondes.py b/Telegram_sondes.py new file mode 100644 index 0000000..f89a4cb --- /dev/null +++ b/Telegram_sondes.py @@ -0,0 +1,323 @@ +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()