485 lines
23 KiB
Python
485 lines
23 KiB
Python
import logging
|
|
import subprocess
|
|
import os
|
|
import datetime
|
|
import requests
|
|
from functools import wraps
|
|
from zoneinfo import ZoneInfo
|
|
from dateutil import parser
|
|
from typing import Dict, List, Optional, Tuple
|
|
|
|
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update
|
|
from telegram.ext import (
|
|
Application,
|
|
CommandHandler,
|
|
CallbackQueryHandler,
|
|
ContextTypes,
|
|
JobQueue
|
|
)
|
|
|
|
# =============================================================================
|
|
# LOOGLE BOT V7.9 (ULTIMATE + GLOBAL GFS FIX)
|
|
# - Dashboard Sistema
|
|
# - Meteo Smart: Arome (EU), Icon (EU-Est), JMA (JP), GFS (Mondo)
|
|
# - Multi-User Security
|
|
# =============================================================================
|
|
|
|
# --- CONFIGURAZIONE ---
|
|
BOT_TOKEN = os.environ.get('BOT_TOKEN')
|
|
|
|
# Gestione Multi-Utente
|
|
allowed_users_raw = os.environ.get('ALLOWED_USER_ID', '')
|
|
ALLOWED_IDS = [int(x.strip()) for x in allowed_users_raw.split(',') if x.strip().isdigit()]
|
|
|
|
# Configurazione Sistema
|
|
SSH_USER = "daniely"
|
|
NAS_USER = "daniely"
|
|
MASTER_IP = "192.168.128.80"
|
|
|
|
# Configurazione Meteo
|
|
HOME_LAT = 43.9356
|
|
HOME_LON = 12.4296
|
|
HOME_NAME = "🏠 Casa (Strada Cà Toro)"
|
|
TZ = "Europe/Rome"
|
|
TZINFO = ZoneInfo(TZ)
|
|
|
|
OPEN_METEO_URL = "https://api.open-meteo.com/v1/forecast"
|
|
GEOCODING_URL = "https://geocoding-api.open-meteo.com/v1/search"
|
|
HTTP_HEADERS = {"User-Agent": "loogle-bot-v7.9"}
|
|
|
|
# --- LISTE DISPOSITIVI ---
|
|
CORE_DEVICES = [
|
|
{"name": "🍓 Pi-1 (Master)", "ip": MASTER_IP, "type": "pi", "user": SSH_USER},
|
|
{"name": "🍓 Pi-2 (Backup)", "ip": "127.0.0.1", "type": "local", "user": ""},
|
|
{"name": "🗄️ NAS 920+", "ip": "192.168.128.100", "type": "nas", "user": NAS_USER},
|
|
{"name": "🗄️ NAS 214", "ip": "192.168.128.90", "type": "nas", "user": NAS_USER}
|
|
]
|
|
|
|
INFRA_DEVICES = [
|
|
{"name": "📡 Router", "ip": "192.168.128.1"},
|
|
{"name": "📶 WiFi Sala", "ip": "192.168.128.101"},
|
|
{"name": "📶 WiFi Luca", "ip": "192.168.128.102"},
|
|
{"name": "📶 WiFi Taverna", "ip": "192.168.128.103"},
|
|
{"name": "📶 WiFi Dado", "ip": "192.168.128.104"},
|
|
{"name": "🔌 Sw Sala", "ip": "192.168.128.105"},
|
|
{"name": "🔌 Sw Main", "ip": "192.168.128.106"},
|
|
{"name": "🔌 Sw Lav", "ip": "192.168.128.107"},
|
|
{"name": "🔌 Sw Tav", "ip": "192.168.128.108"}
|
|
]
|
|
|
|
logging.basicConfig(format="%(asctime)s - %(levelname)s - %(message)s", level=logging.INFO)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# =============================================================================
|
|
# SEZIONE 1: FUNZIONI SISTEMA (SSH, PING, UTILS)
|
|
# =============================================================================
|
|
|
|
def run_cmd(command, ip=None, user=None):
|
|
try:
|
|
if ip == "127.0.0.1" or ip is None:
|
|
return subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT, timeout=5).decode('utf-8').strip()
|
|
else:
|
|
safe_cmd = command.replace("'", "'\\''")
|
|
full_cmd = f"ssh -o LogLevel=ERROR -o BatchMode=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=3 {user}@{ip} '{safe_cmd}'"
|
|
return subprocess.check_output(full_cmd, shell=True, stderr=subprocess.STDOUT, timeout=8).decode('utf-8').strip()
|
|
except Exception: return "Err"
|
|
|
|
def get_ping_icon(ip):
|
|
try:
|
|
subprocess.run(["ping", "-c", "1", "-W", "1", ip], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=0.8, check=True)
|
|
return "✅"
|
|
except Exception: return "🔴"
|
|
|
|
def get_device_stats(device):
|
|
ip, user, dtype = device['ip'], device['user'], device['type']
|
|
uptime_raw = run_cmd("uptime -p 2>/dev/null || uptime", ip, user)
|
|
if not uptime_raw or "Err" in uptime_raw: return "🔴 **OFFLINE**"
|
|
|
|
uptime = uptime_raw.replace("up ", "").split(", load")[0].split(", ")[0]
|
|
temp = "N/A"
|
|
|
|
if dtype in ["pi", "local"]:
|
|
t = run_cmd("cat /sys/class/thermal/thermal_zone0/temp", ip, user)
|
|
if t.isdigit(): temp = f"{int(t)/1000:.1f}°C"
|
|
elif dtype == "nas":
|
|
t = run_cmd("cat /sys/class/hwmon/hwmon0/temp1_input 2>/dev/null || cat /sys/class/thermal/thermal_zone0/temp", ip, user)
|
|
if t.isdigit():
|
|
v = int(t); temp = f"{v/1000:.1f}°C" if v > 1000 else f"{v}°C"
|
|
|
|
if dtype == "nas": ram_cmd = "free | grep Mem | awk '{printf \"%.0f%%\", $3*100/$2}'"
|
|
else: ram_cmd = "free -m | awk 'NR==2{if ($2>0) printf \"%.0f%%\", $3*100/$2; else print \"0%\"}'"
|
|
disk_path = "/" if dtype != "nas" else "/volume1"
|
|
disk_cmd = f"df -h {disk_path} | awk 'NR==2{{print $5}}'"
|
|
return f"✅ **ONLINE**\n⏱️ Up: {uptime}\n🌡️ Temp: {temp} | 🧠 RAM: {run_cmd(ram_cmd, ip, user)} | 💾 Disk: {run_cmd(disk_cmd, ip, user)}"
|
|
|
|
def read_log_file(filepath, lines=15):
|
|
if not os.path.exists(filepath): return "⚠️ File non trovato."
|
|
try: return subprocess.check_output(['tail', '-n', str(lines), filepath], stderr=subprocess.STDOUT).decode('utf-8')
|
|
except Exception as e: return f"Errore: {str(e)}"
|
|
|
|
def run_speedtest():
|
|
try: return subprocess.check_output("speedtest-cli --simple", shell=True, timeout=50).decode('utf-8')
|
|
except: return "Errore Speedtest"
|
|
|
|
# =============================================================================
|
|
# SEZIONE 2: METEO INTELLIGENTE (MULTI-MODELLO MOSAICO)
|
|
# =============================================================================
|
|
|
|
def now_local() -> datetime.datetime:
|
|
return datetime.datetime.now(TZINFO)
|
|
|
|
def parse_time(t: str) -> datetime.datetime:
|
|
dt = parser.isoparse(t)
|
|
if dt.tzinfo is None: return dt.replace(tzinfo=TZINFO)
|
|
return dt.astimezone(TZINFO)
|
|
|
|
def degrees_to_cardinal(d: int) -> str:
|
|
dirs = ["N", "NE", "E", "SE", "S", "SW", "W", "NW"]
|
|
return dirs[round(d / 45) % 8]
|
|
|
|
def get_icon_set(prec, snow, code, is_day, cloud, vis, temp, rain, gust, cape):
|
|
sky = "☁️"
|
|
if code in (95, 96, 99): sky = "⛈️" if prec > 0 else "🌩️"
|
|
elif (code in (45, 48) or vis < 1000) and prec < 1: sky = "🌫️"
|
|
elif prec >= 0.1: sky = "🌨️" if snow > 0 else "🌧️"
|
|
elif cloud <= 20: sky = "☀️" if is_day else "🌙"
|
|
elif cloud <= 40: sky = "🌤️" if is_day else "🌙"
|
|
elif cloud <= 60: sky = "⛅️"
|
|
elif cloud <= 80: sky = "🌥️"
|
|
|
|
sgx = "-"
|
|
if snow > 0 or (code in (71,73,75,77,85,86) if code else False): sgx = "☃️"
|
|
elif temp < 0 or (code in (66,67) if code else False): sgx = "🧊"
|
|
elif cape > 2000: sgx = "🌪️"
|
|
elif cape > 1000: sgx = "⚡"
|
|
elif temp > 35: sgx = "🥵"
|
|
elif rain > 4: sgx = "☔️"
|
|
elif gust > 50: sgx = "💨"
|
|
return sky, sgx
|
|
|
|
def get_coordinates(city_name: str):
|
|
"""
|
|
Cerca le coordinate della città con fallback EN.
|
|
"""
|
|
# 1. Tentativo ITALIANO
|
|
params = {"name": city_name, "count": 10, "language": "it", "format": "json"}
|
|
try:
|
|
r = requests.get(GEOCODING_URL, params=params, headers=HTTP_HEADERS, timeout=10)
|
|
data = r.json()
|
|
if "results" in data and len(data["results"]) > 0:
|
|
res = data["results"][0]
|
|
cc = res.get("country_code", "IT").upper()
|
|
name = f"{res.get('name')} ({cc})"
|
|
return res["latitude"], res["longitude"], name, cc
|
|
except Exception as e: logger.error(f"Geocoding IT error: {e}")
|
|
|
|
# 2. Tentativo FALLBACK INGLESE
|
|
try:
|
|
params["language"] = "en"
|
|
r = requests.get(GEOCODING_URL, params=params, headers=HTTP_HEADERS, timeout=10)
|
|
data = r.json()
|
|
if "results" in data and len(data["results"]) > 0:
|
|
res = data["results"][0]
|
|
cc = res.get("country_code", "IT").upper()
|
|
name = f"{res.get('name')} ({cc})"
|
|
return res["latitude"], res["longitude"], name, cc
|
|
except Exception as e: logger.error(f"Geocoding EN error: {e}")
|
|
|
|
return None
|
|
|
|
def choose_best_model(lat, lon, cc):
|
|
"""
|
|
Seleziona il modello migliore.
|
|
Fallback Generale: NOAA GFS (perché ha sempre Visibilità/Cape).
|
|
"""
|
|
|
|
# 1. GIAPPONE -> JMA MSM
|
|
if cc == 'JP':
|
|
return "jma_msm", "JMA MSM (5km)"
|
|
|
|
# 2. SCANDINAVIA -> Yr.no
|
|
if cc in ['NO', 'SE', 'FI', 'DK', 'IS']:
|
|
return "metno_nordic", "Yr.no (Nordic)"
|
|
|
|
# 3. UK & IRLANDA -> UK Met Office
|
|
if cc in ['GB', 'IE']:
|
|
return "ukmo_global", "UK MetOffice"
|
|
|
|
# 4. TUNING ITALIA (Mosaico)
|
|
if cc == 'IT' or cc == 'SM':
|
|
# ZONA 1: Nord-Ovest, Tirreno, Sardegna (Lon <= 13.0, Lat > 40.5)
|
|
if lon <= 13.0 and lat > 40.5:
|
|
return "meteofrance_arome_france_hd", "Arome HD"
|
|
# ZONA 2: Nord-Est, Adriatico Nord/Centro
|
|
if lat >= 43.0:
|
|
return "icon_d2", "ICON-D2 (2km)"
|
|
# ZONA 3: Sud Italia -> ICON-EU (Meglio di GFS per locale)
|
|
return "icon_eu", "ICON-EU (7km)"
|
|
|
|
# 5. RESTO DEL MONDO (Europa Centrale ICON-D2)
|
|
if cc in ['DE', 'AT', 'CH', 'LI']:
|
|
return "icon_d2", "ICON-D2"
|
|
|
|
# 6. RESTO DEL MONDO -> NOAA GFS
|
|
# Usiamo GFS invece di ECMWF perché ECMWF spesso manca di 'visibility'/'cape'
|
|
# facendo crashare o svuotare il report. GFS è completo.
|
|
return "gfs_global", "NOAA GFS Global"
|
|
|
|
def get_forecast(lat, lon, model):
|
|
params = {
|
|
"latitude": lat, "longitude": lon, "timezone": TZ,
|
|
"forecast_days": 3,
|
|
"models": model,
|
|
"wind_speed_unit": "kmh", "precipitation_unit": "mm",
|
|
"hourly": "temperature_2m,relative_humidity_2m,cloudcover,windspeed_10m,winddirection_10m,windgusts_10m,precipitation,rain,snowfall,weathercode,is_day,cape,visibility"
|
|
}
|
|
try:
|
|
r = requests.get(OPEN_METEO_URL, params=params, headers=HTTP_HEADERS, timeout=25)
|
|
r.raise_for_status()
|
|
return r.json()
|
|
except Exception as e: logger.error(f"Meteo API error: {e}"); return None
|
|
|
|
def safe_get_list(hourly_data, key, length, default=None):
|
|
"""Estrae una lista sicura, gestendo chiavi mancanti"""
|
|
if key in hourly_data and hourly_data[key] is not None:
|
|
return hourly_data[key]
|
|
return [default] * length
|
|
|
|
def generate_weather_report(lat, lon, location_name, cc="IT") -> str:
|
|
model_id, model_name = choose_best_model(lat, lon, cc)
|
|
|
|
data = get_forecast(lat, lon, model_id)
|
|
if not data: return f"❌ Errore API Meteo ({model_name})."
|
|
|
|
hourly = data.get("hourly", {})
|
|
times = hourly.get("time", [])
|
|
if not times: return "❌ Dati orari mancanti."
|
|
|
|
L = len(times)
|
|
|
|
try:
|
|
l_temp = safe_get_list(hourly, "temperature_2m", L, 0)
|
|
l_rh = safe_get_list(hourly, "relative_humidity_2m", L, 0)
|
|
l_cl = safe_get_list(hourly, "cloudcover", L, 0)
|
|
l_prec = safe_get_list(hourly, "precipitation", L, 0)
|
|
l_rain = safe_get_list(hourly, "rain", L, 0)
|
|
l_snow = safe_get_list(hourly, "snowfall", L, 0)
|
|
l_wspd = safe_get_list(hourly, "windspeed_10m", L, 0)
|
|
l_gust = safe_get_list(hourly, "windgusts_10m", L, 0)
|
|
l_wdir = safe_get_list(hourly, "winddirection_10m", L, 0)
|
|
l_code = safe_get_list(hourly, "weathercode", L, 0)
|
|
l_day = safe_get_list(hourly, "is_day", L, 1)
|
|
l_cape = safe_get_list(hourly, "cape", L, 0)
|
|
l_vis = safe_get_list(hourly, "visibility", L, 10000)
|
|
|
|
except Exception as e:
|
|
return f"❌ Errore elaborazione dati meteo: {e}"
|
|
|
|
now = now_local().replace(minute=0, second=0, microsecond=0)
|
|
blocks = []
|
|
|
|
for (label, hours_duration, step) in [("Prime 24h", 24, 1), ("Successive 24h", 24, 2)]:
|
|
end_time = now + datetime.timedelta(hours=hours_duration)
|
|
lines = [f"{'LT':<2} {'T°':>3} {'h%':>3} {'mm':>2} {'Vento':<5} {'Nv%':>3} {'Sky':<2} {'Sgx':<3}", "-" * 30]
|
|
count = 0
|
|
for i, t_str in enumerate(times):
|
|
try: dt = parse_time(t_str)
|
|
except: continue
|
|
if dt < now or dt >= end_time: continue
|
|
if dt.hour % step != 0: continue
|
|
|
|
try:
|
|
T = float(l_temp[i])
|
|
Rh = int(l_rh[i] or 0)
|
|
Cl = int(l_cl[i] or 0)
|
|
Pr = float(l_prec[i] or 0)
|
|
Rn = float(l_rain[i] or 0)
|
|
Sn = float(l_snow[i] or 0)
|
|
Wspd = float(l_wspd[i] or 0)
|
|
Gust = float(l_gust[i] or 0)
|
|
Wdir = int(l_wdir[i] or 0)
|
|
Cape = float(l_cape[i] or 0)
|
|
Vis = float(l_vis[i] or 10000)
|
|
Code = int(l_code[i]) if l_code[i] is not None else None
|
|
IsDay = int(l_day[i] if l_day[i] is not None else 1)
|
|
|
|
t_s = f"{int(round(T))}"
|
|
p_s = "--" if Pr < 0.2 else f"{int(round(Pr))}"
|
|
card = degrees_to_cardinal(Wdir)
|
|
w_val = Gust if (Gust - Wspd) > 15 else Wspd
|
|
w_txt = f"{card} {int(round(w_val))}"
|
|
if (Gust - Wspd) > 15:
|
|
g_txt = f"G{int(round(w_val))}"
|
|
if len(card)+len(g_txt) <= 5: w_txt = f"{card}{g_txt}"
|
|
elif len(card)+1+len(g_txt) <= 5: w_txt = f"{card} {g_txt}"
|
|
else: w_txt = g_txt
|
|
w_fmt = f"{w_txt:<5}"
|
|
sky, sgx = get_icon_set(Pr, Sn, Code, IsDay, Cl, Vis, T, Rn, Gust, Cape)
|
|
lines.append(f"{dt.strftime('%H'):<2} {t_s:>3} {Rh:>3} {p_s:>2} {w_fmt} {Cl:>3} {sky:<2} {sgx:<3}")
|
|
count += 1
|
|
except: continue
|
|
if count > 0:
|
|
day_label = f"{['Lun','Mar','Mer','Gio','Ven','Sab','Dom'][now.weekday()]} {now.day}"
|
|
blocks.append(f"*{day_label} ({label})*\n```text\n" + "\n".join(lines) + "\n```")
|
|
now = end_time
|
|
|
|
return f"🌤️ *METEO REPORT*\n📍 {location_name}\n🧠 Fonte: {model_name}\n\n" + "\n\n".join(blocks)
|
|
|
|
# =============================================================================
|
|
# SEZIONE 3: BOT HANDLERS & SCHEDULER
|
|
# =============================================================================
|
|
|
|
# Decoratore Sicurezza Multi-Utente
|
|
def restricted(func):
|
|
@wraps(func)
|
|
async def wrapped(update: Update, context: ContextTypes.DEFAULT_TYPE, *args, **kwargs):
|
|
user_id = update.effective_user.id
|
|
if user_id not in ALLOWED_IDS:
|
|
logger.warning(f"⚠️ ACCESSO NEGATO: User {user_id}")
|
|
return
|
|
return await func(update, context, *args, **kwargs)
|
|
return wrapped
|
|
|
|
@restricted
|
|
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
|
keyboard = [
|
|
[InlineKeyboardButton("🖥️ Core Server", callback_data="menu_core"), InlineKeyboardButton("🔍 Scan LAN", callback_data="menu_lan")],
|
|
[InlineKeyboardButton("🛡️ Pi-hole", callback_data="menu_pihole"), InlineKeyboardButton("🌐 Rete", callback_data="menu_net")],
|
|
[InlineKeyboardButton("🌤️ Meteo Casa", callback_data="req_meteo_home"), InlineKeyboardButton("📜 Logs", callback_data="menu_logs")]
|
|
]
|
|
text = "🎛 **Loogle Control Center v7.9**\nComandi disponibili:\n🔹 `/meteo <città>`\n🔹 Pulsanti sotto"
|
|
|
|
if update.message: await update.message.reply_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
|
|
else: await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
|
|
|
|
@restricted
|
|
async def meteo_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
|
if not context.args:
|
|
await update.message.reply_text("⚠️ Usa: `/meteo <città>` (es. `/meteo Rimini`)", parse_mode="Markdown")
|
|
return
|
|
|
|
city = " ".join(context.args)
|
|
await update.message.reply_text(f"🔄 Cerco '{city}'...", parse_mode="Markdown")
|
|
|
|
coords = get_coordinates(city)
|
|
if coords:
|
|
lat, lon, name, cc = coords
|
|
report = generate_weather_report(lat, lon, name, cc)
|
|
await update.message.reply_text(report, parse_mode="Markdown")
|
|
else:
|
|
await update.message.reply_text(f"❌ Città '{city}' non trovata.", parse_mode="Markdown")
|
|
|
|
async def scheduled_morning_report(context: ContextTypes.DEFAULT_TYPE) -> None:
|
|
logger.info("⏰ Invio report automatico meteo...")
|
|
# Forza "SM" per casa -> Arome/IconD2 in base alla posizione
|
|
report = generate_weather_report(HOME_LAT, HOME_LON, HOME_NAME, "SM")
|
|
for uid in ALLOWED_IDS:
|
|
try: await context.bot.send_message(chat_id=uid, text=report, parse_mode="Markdown")
|
|
except: pass
|
|
|
|
@restricted
|
|
async def button_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
|
|
query = update.callback_query
|
|
await query.answer()
|
|
data = query.data
|
|
|
|
if data == "main_menu": await start(update, context)
|
|
|
|
elif data == "req_meteo_home":
|
|
await query.edit_message_text("⏳ **Scaricamento Meteo Casa...**", parse_mode="Markdown")
|
|
# Forza "SM" per casa
|
|
report = generate_weather_report(HOME_LAT, HOME_LON, HOME_NAME, "SM")
|
|
keyboard = [[InlineKeyboardButton("⬅️ Indietro", callback_data="main_menu")]]
|
|
await query.edit_message_text(report, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
|
|
|
|
elif data == "menu_core":
|
|
keyboard = []
|
|
for i, dev in enumerate(CORE_DEVICES): keyboard.append([InlineKeyboardButton(dev['name'], callback_data=f"stat_{i}")])
|
|
keyboard.append([InlineKeyboardButton("📊 Report Completo", callback_data="stat_all")])
|
|
keyboard.append([InlineKeyboardButton("⬅️ Indietro", callback_data="main_menu")])
|
|
await query.edit_message_text("🖥️ **Core Servers**", reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
|
|
|
|
elif data == "stat_all":
|
|
await query.edit_message_text("⏳ **Analisi...**", parse_mode="Markdown")
|
|
report = "📊 **REPORT CORE**\n"
|
|
for dev in CORE_DEVICES: report += f"\n🔹 **{dev['name']}**\n{get_device_stats(dev)}\n"
|
|
await query.edit_message_text(report, reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("⬅️ Indietro", callback_data="menu_core")]]), parse_mode="Markdown")
|
|
|
|
elif data.startswith("stat_"):
|
|
dev = CORE_DEVICES[int(data.split("_")[1])]
|
|
await query.edit_message_text(f"⏳ Controllo {dev['name']}...", parse_mode="Markdown")
|
|
await query.edit_message_text(f"🔹 **{dev['name']}**\n\n{get_device_stats(dev)}", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("⬅️ Indietro", callback_data="menu_core")]]), parse_mode="Markdown")
|
|
|
|
elif data == "menu_lan":
|
|
await query.edit_message_text("⏳ **Scansione LAN...**", parse_mode="Markdown")
|
|
report = "🔍 **DIAGNOSTICA LAN**\n\n"
|
|
try:
|
|
for dev in CORE_DEVICES: report += f"{get_ping_icon(dev['ip'])} `{dev['ip']}` - {dev['name']}\n"
|
|
report += "\n"
|
|
for dev in INFRA_DEVICES: report += f"{get_ping_icon(dev['ip'])} `{dev['ip']}` - {dev['name']}\n"
|
|
except Exception as e: report += f"\n⚠️ Errore: {e}"
|
|
keyboard = [[InlineKeyboardButton("⚡ Menu Riavvio", callback_data="menu_reboot")], [InlineKeyboardButton("🔄 Aggiorna", callback_data="menu_lan"), InlineKeyboardButton("⬅️ Indietro", callback_data="main_menu")]]
|
|
await query.edit_message_text(report, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
|
|
|
|
elif data == "menu_reboot":
|
|
keyboard = []
|
|
for i, dev in enumerate(INFRA_DEVICES):
|
|
if "Router" not in dev['name']: keyboard.append([InlineKeyboardButton(f"⚡ {dev['name']}", callback_data=f"reboot_{i}")])
|
|
keyboard.append([InlineKeyboardButton("⬅️ Indietro", callback_data="menu_lan")])
|
|
await query.edit_message_text("⚠️ **RIAVVIO REMOTO**", reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
|
|
|
|
elif data.startswith("reboot_"):
|
|
dev = INFRA_DEVICES[int(data.split("_")[1])]
|
|
res = run_cmd("reboot", dev['ip'], "admin")
|
|
await query.edit_message_text(f"⚡ Inviato a {dev['name']}...\n\n`{res}`", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("⬅️ Indietro", callback_data="menu_reboot")]]), parse_mode="Markdown")
|
|
|
|
elif data == "menu_pihole":
|
|
status_raw = run_cmd("sudo pihole status", MASTER_IP, SSH_USER)
|
|
icon = "✅" if "Enabled" in status_raw or "enabled" in status_raw else "🔴"
|
|
text = f"🛡️ **Pi-hole Master**\nStato: {icon}\n\n`{status_raw}`"
|
|
keyboard = [[InlineKeyboardButton("⏸️ 5m", callback_data="ph_disable_300"), InlineKeyboardButton("⏸️ 30m", callback_data="ph_disable_1800")], [InlineKeyboardButton("▶️ Attiva", callback_data="ph_enable"), InlineKeyboardButton("🔄 Restart", callback_data="ph_restart")], [InlineKeyboardButton("⬅️ Indietro", callback_data="main_menu")]]
|
|
await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
|
|
|
|
elif data.startswith("ph_"):
|
|
if "disable" in data: run_cmd(f"sudo pihole disable {data.split('_')[2]}s", MASTER_IP, SSH_USER)
|
|
elif "enable" in data: run_cmd("sudo pihole enable", MASTER_IP, SSH_USER)
|
|
elif "restart" in data: run_cmd("sudo systemctl restart pihole-FTL", MASTER_IP, SSH_USER)
|
|
await query.edit_message_text("✅ Comando inviato.", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("⬅️ Indietro", callback_data="menu_pihole")]]), parse_mode="Markdown")
|
|
|
|
elif data == "menu_net":
|
|
ip = run_cmd("curl -s ifconfig.me")
|
|
keyboard = [[InlineKeyboardButton("🚀 Speedtest", callback_data="net_speedtest")], [InlineKeyboardButton("⬅️ Indietro", callback_data="main_menu")]]
|
|
await query.edit_message_text(f"🌐 **Rete**\n🌍 IP: `{ip}`", reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
|
|
|
|
elif data == "net_speedtest":
|
|
await query.edit_message_text("🚀 **Speedtest...**", parse_mode="Markdown")
|
|
res = run_speedtest()
|
|
await query.edit_message_text(f"🚀 **Risultato:**\n\n`{res}`", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("⬅️ Indietro", callback_data="menu_net")]]), parse_mode="Markdown")
|
|
|
|
elif data == "menu_logs":
|
|
keyboard = [[InlineKeyboardButton("🐶 Watchdog", callback_data="log_wd"), InlineKeyboardButton("💾 Backup", callback_data="log_bk")], [InlineKeyboardButton("🔄 NPM Sync", callback_data="log_npm"), InlineKeyboardButton("⬅️ Indietro", callback_data="main_menu")]]
|
|
await query.edit_message_text("📜 **Logs**", reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
|
|
|
|
elif data.startswith("log_"):
|
|
paths = {"log_wd": "/logs/dhcp-watchdog.log", "log_bk": "/logs/raspiBackup.log", "log_npm": "/logs/sync-npm.log"}
|
|
log_c = read_log_file(paths[data])
|
|
await query.edit_message_text(f"📜 **Log:**\n\n`{log_c}`", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("⬅️ Indietro", callback_data="menu_logs")]]), parse_mode="Markdown")
|
|
|
|
def main():
|
|
logger.info("Avvio Loogle Bot v7.9 (Global GFS Fix)...")
|
|
application = Application.builder().token(BOT_TOKEN).build()
|
|
|
|
# Handlers
|
|
application.add_handler(CommandHandler("start", start))
|
|
application.add_handler(CommandHandler("meteo", meteo_command))
|
|
application.add_handler(CallbackQueryHandler(button_handler))
|
|
|
|
# SCHEDULER
|
|
job_queue = application.job_queue
|
|
job_queue.run_daily(scheduled_morning_report, time=datetime.time(hour=8, minute=0, tzinfo=TZINFO), days=(0, 1, 2, 3, 4, 5, 6))
|
|
|
|
application.run_polling()
|
|
|
|
if __name__ == "__main__":
|
|
main()
|