meb/signalk-plugin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Aggiunto collegamento al server

Browse Source
This commit is contained in:
Giuseppe Raffa
2026-03-11 15:25:03 +01:00
parent c37f30e4ea
commit 41f33ce181
51 changed files with 3088 additions and 4414 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
plugin/telegram/callbacks/dashboard.js Normal file
View File

@@ -0,0 +1,152 @@
// Mappa globale per salvare gli interval id anche dopo un "hot-reload"
if (!global.__meb_live_dashboards) {
global.__meb_live_dashboards = new Map();
}
module.exports = [
{
id: 'dashboard-refresh',
execute: async ({ bot, chatId, msg }) => {
const dash = require('../commands/dashboard.js');
const newText = dash.formatSensorData();
try {
await bot.editMessageText(newText, {
chat_id: chatId,
message_id: msg.message_id,
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[
{ text: "⚡️ Avvia Live Tracker (2s)", callback_data: 'dashboard-live-start' }
],
[
{ text: "🔄 Ricarica Dati", callback_data: 'dashboard-refresh' }
]
]
}
});
} catch (e) {
if (!e.message.includes('message is not modified')) {
console.error("Errore nel refresh dashboard:", e);
}
}
}
},
{
id: 'dashboard-live-start',
execute: async ({ bot, chatId, msg }) => {
const dash = require('../commands/dashboard.js');
const messageId = msg.message_id;
const liveKey = `${chatId}_${messageId}`;
// Se è già attivo un live per questo messaggio, non fare nulla
if (global.__meb_live_dashboards.has(liveKey)) return;
// Avvisa che sta partendo
const startMarkup = {
inline_keyboard: [
[
{ text: "🛑 Ferma Live Tracker", callback_data: 'dashboard-live-stop' }
]
]
};
await bot.editMessageReplyMarkup(startMarkup, { chat_id: chatId, message_id: messageId });
// Inizializza l'interval a 2 secondi. Autodistruzione dopo 30s
let count = 15; // 15 tick da 2 secondi = 30 secondi
const intervalTimer = setInterval(async () => {
count--;
const baseText = dash.formatSensorData();
// Se il tempo scade, disattiva il live e ripristina i tasti normali
if (count <= 0) {
if (global.__meb_live_dashboards.has(liveKey)) {
clearInterval(global.__meb_live_dashboards.get(liveKey));
global.__meb_live_dashboards.delete(liveKey);
}
try {
await bot.editMessageText(baseText + `\n🛑 _Live tracker terminato automaticamente (30s) per risparmiare risorse._`, {
chat_id: chatId,
message_id: messageId,
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[{ text: "⚡️ Avvia Live Tracker (2s)", callback_data: 'dashboard-live-start' }],
[{ text: "🔄 Ricarica Dati", callback_data: 'dashboard-refresh' }]
]
}
});
} catch (e) { }
return;
}
// Altrimenti prosegui con l'aggiornamento e la stringa del countdown
const newText = baseText + `\n⏳ _Live attivo: arresto automatico tra *${count * 2}s*_`;
try {
await bot.editMessageText(newText, {
chat_id: chatId,
message_id: messageId,
parse_mode: 'Markdown',
reply_markup: startMarkup
});
} catch (e) {
// API limits o the message was not modified
if (e.response && e.response.statusCode === 400 && e.message.includes("message is not modified")) {
// ignore
} else if (e.response && e.response.statusCode === 429) {
// Troppe richieste Telegram
console.warn("[Telegram Dashboard] Rate Limit raggionto. Riprovo più tardi...");
} else if (e.response && e.response.statusCode === 400 && e.message.includes("message to edit not found")) {
// Il messaggio è stato cancellato dall'utente
clearInterval(intervalTimer);
global.__meb_live_dashboards.delete(liveKey);
} else {
console.error("[Telegram Dashboard] Errore update live:", e);
}
}
}, 2000);
global.__meb_live_dashboards.set(liveKey, intervalTimer);
}
},
{
id: 'dashboard-live-stop',
execute: async ({ bot, chatId, msg }) => {
const dash = require('../commands/dashboard.js');
const messageId = msg.message_id;
const liveKey = `${chatId}_${messageId}`;
// Pulisci l'interval se esiste
if (global.__meb_live_dashboards.has(liveKey)) {
clearInterval(global.__meb_live_dashboards.get(liveKey));
global.__meb_live_dashboards.delete(liveKey);
}
// Ripristina la formattazione iniziale
const newText = dash.formatSensorData();
try {
await bot.editMessageText(newText, {
chat_id: chatId,
message_id: messageId,
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[
{ text: "⚡️ Avvia Live Tracker (2s)", callback_data: 'dashboard-live-start' }
],
[
{ text: "🔄 Ricarica Dati", callback_data: 'dashboard-refresh' }
]
]
}
});
} catch (e) { }
}
}
];

26
plugin/telegram/callbacks/data.js Normal file
View File

@@ -0,0 +1,26 @@
module.exports = [
{
id: 'data-refresh',
execute: async ({ bot, chatId, msg }) => {
const dataCmd = require('../commands/data.js');
const newText = dataCmd.formatSensorData();
try {
await bot.editMessageText(newText, {
chat_id: chatId,
message_id: msg.message_id,
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[{ text: 'Aggiorna', callback_data: 'data-refresh' }]
]
}
});
} catch (e) {
if (!e.message.includes('message is not modified')) {
console.error('[Telegram Data] Errore refresh:', e.message);
}
}
}
}
];

141
plugin/telegram/callbacks/live.js Normal file
View File

@@ -0,0 +1,141 @@
// Mappa globale per salvare gli interval id anche dopo un "hot-reload"
if (!global.__meb_live_trackers) {
global.__meb_live_trackers = new Map();
}
module.exports = [
{
id: 'live-refresh',
execute: async ({ bot, chatId, msg }) => {
const liveCmd = require('../commands/live.js');
const newText = liveCmd.formatLiveData();
try {
await bot.editMessageText(newText, {
chat_id: chatId,
message_id: msg.message_id,
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[{ text: 'Avvia Live (2s)', callback_data: 'live-start' }],
[{ text: 'Aggiorna', callback_data: 'live-refresh' }]
]
}
});
} catch (e) {
if (!e.message.includes('message is not modified')) {
console.error('[Telegram Live] Errore refresh:', e.message);
}
}
}
},
{
id: 'live-start',
execute: async ({ bot, chatId, msg }) => {
const liveCmd = require('../commands/live.js');
const messageId = msg.message_id;
const liveKey = `${chatId}_${messageId}`;
// Se gia' attivo per questo messaggio, ignora
if (global.__meb_live_trackers.has(liveKey)) return;
const stopMarkup = {
inline_keyboard: [
[{ text: 'Ferma Live', callback_data: 'live-stop' }]
]
};
await bot.editMessageReplyMarkup(stopMarkup, {
chat_id: chatId,
message_id: messageId
});
// 30 tick da 2 secondi = 60 secondi, poi auto-stop
let count = 30;
const intervalTimer = setInterval(async () => {
count--;
const baseText = liveCmd.formatLiveData();
// Auto-stop quando il tempo scade
if (count <= 0) {
if (global.__meb_live_trackers.has(liveKey)) {
clearInterval(global.__meb_live_trackers.get(liveKey));
global.__meb_live_trackers.delete(liveKey);
}
try {
await bot.editMessageText(
baseText + `\n_Live terminato automaticamente (60s)._`,
{
chat_id: chatId,
message_id: messageId,
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[{ text: 'Avvia Live (2s)', callback_data: 'live-start' }],
[{ text: 'Aggiorna', callback_data: 'live-refresh' }]
]
}
}
);
} catch (e) { /* ignore */ }
return;
}
// Aggiornamento live con countdown
const newText = baseText + `\n_Live attivo: arresto tra *${count * 2}s*_`;
try {
await bot.editMessageText(newText, {
chat_id: chatId,
message_id: messageId,
parse_mode: 'Markdown',
reply_markup: stopMarkup
});
} catch (e) {
if (e.response && e.response.statusCode === 429) {
console.warn('[Telegram Live] Rate limit raggiunto');
} else if (e.message && e.message.includes('message to edit not found')) {
// Messaggio cancellato dall'utente
clearInterval(intervalTimer);
global.__meb_live_trackers.delete(liveKey);
}
// Ignora "message is not modified"
}
}, 2000);
global.__meb_live_trackers.set(liveKey, intervalTimer);
}
},
{
id: 'live-stop',
execute: async ({ bot, chatId, msg }) => {
const liveCmd = require('../commands/live.js');
const messageId = msg.message_id;
const liveKey = `${chatId}_${messageId}`;
// Pulisci l'interval se esiste
if (global.__meb_live_trackers.has(liveKey)) {
clearInterval(global.__meb_live_trackers.get(liveKey));
global.__meb_live_trackers.delete(liveKey);
}
const newText = liveCmd.formatLiveData();
try {
await bot.editMessageText(newText + '\n_Live fermato._', {
chat_id: chatId,
message_id: messageId,
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[{ text: 'Avvia Live (2s)', callback_data: 'live-start' }],
[{ text: 'Aggiorna', callback_data: 'live-refresh' }]
]
}
});
} catch (e) { /* ignore */ }
}
}
];

51
plugin/telegram/callbacks/logs.js Normal file
View File

@@ -0,0 +1,51 @@
const realtime = require('../../realtime/core.js');
const { config } = require('../../config.js');
module.exports = [
{
id: 'logs-refresh',
execute: async ({ bot, chatId, msg }) => {
const stats = realtime.getStats();
const consoleUrl = config.cloudUrl || 'https://console.mebboat.it';
let statusIcon = '🔴';
if (stats.status === 'connected') statusIcon = '🟢';
else if (stats.status === 'error') statusIcon = '🟡';
const now = new Date().toLocaleTimeString('it-IT');
let text = `📊 *Registrazione Dati Realtime*\n\n`;
text += `Stato: ${statusIcon} *${stats.status}*\n`;
text += `Sensore: \`${stats.sensorID}\`\n`;
text += `Messaggi inviati: *${stats.sent}*\n`;
text += `Frequenza: ogni *${stats.sentEveryMLS / 1000}s*\n`;
if (stats.buffered > 0) {
text += `⚠️ Messaggi in buffer: *${stats.buffered}*\n`;
}
if (stats.reconnections > 0) {
text += `Riconnessioni: ${stats.reconnections}\n`;
}
text += `\n_(Aggiornato: ${now})_`;
try {
await bot.editMessageText(text, {
chat_id: chatId,
message_id: msg.message_id,
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[{ text: '📈 Apri Console Log', url: `${consoleUrl}/logs` }],
[{ text: '🔄 Aggiorna Stato', callback_data: 'logs-refresh' }]
]
}
});
} catch (e) {
if (!e.message.includes('message is not modified')) {
console.error("[Telegram] Errore refresh logs:", e);
}
}
}
}
];

80
plugin/telegram/callbacks/settings.js Normal file
View File

@@ -0,0 +1,80 @@
module.exports = [
{
id: 'set-meteo',
execute: async ({ bot, chatId, app }) => {
const config = app.mebConfig;
const currentFreqMin = config.forecast_current_frequency / 60000;
const hourlyFreqMin = config.forecast_hourly_frequency / 60000;
const msg = `*Configura Aggiornamenti Meteo*\n\n` +
`Aggiorno il meteo (attuale) ogni *${currentFreqMin} minuti*\n` +
`Registro le previsioni future (prossimi 7 giorni) ogni *${hourlyFreqMin} minuti*`;
await bot.sendMessage(chatId, msg, {
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[
{ text: "1 sec", callback_data: 'set-meteo-curr-1' },
{ text: "10 sec", callback_data: 'set-meteo-curr-10' },
],
[
{ text: "1 min", callback_data: 'set-meteo-curr-60' },
{ text: "10 min", callback_data: 'set-meteo-curr-600' }
],
[
{ text: "30m", callback_data: 'set-meteo-hour-1800' }
],
[
{ text: "⬅️ Indietro", callback_data: 'session-refresh' }
]
]
}
});
}
},
{
match: (data) => data.startsWith('set-meteo-curr-'),
execute: async ({ bot, chatId, app, data, msg }) => {
const val = parseInt(data.replace('set-meteo-curr-', ''), 10);
if (app.mebPlugin && app.mebPlugin.setConfig) {
app.mebPlugin.setConfig('forecast_current_frequency', val);
await bot.editMessageText(`✅ Frequenza Aggiornamenti meteo aggiornata a *${val / 60} minuti*.\n_Ritorno al menu..._`, {
chat_id: chatId,
message_id: msg.message_id,
parse_mode: 'Markdown'
});
setTimeout(() => {
const sessionCmd = require('../commands/status.js');
bot.editMessageText("*Servizi*\n\n", {
chat_id: chatId, message_id: msg.message_id, parse_mode: 'Markdown', reply_markup: sessionCmd.createSessionMenu(app).reply_markup
}).catch(() => { });
}, 3000);
} else {
await bot.sendMessage(chatId, "Errore: il plugin non è accessibile per salvare la configurazione.");
}
}
},
{
match: (data) => data.startsWith('set-meteo-hour-'),
execute: async ({ bot, chatId, app, data, msg }) => {
const val = parseInt(data.replace('set-meteo-hour-', ''), 10);
if (app.mebPlugin && app.mebPlugin.setConfig) {
app.mebPlugin.setConfig('forecast_hourly_frequency', val);
await bot.editMessageText(`✅ Frequenza previsioni future aggiornata a *${val / 60} minuti*.\n_Ritorno al menu..._`, {
chat_id: chatId,
message_id: msg.message_id,
parse_mode: 'Markdown'
});
setTimeout(() => {
const sessionCmd = require('../commands/status.js');
bot.editMessageText("*Servizi*\n\n", {
chat_id: chatId, message_id: msg.message_id, parse_mode: 'Markdown', reply_markup: sessionCmd.createSessionMenu(app).reply_markup
}).catch(() => { });
}, 3000);
} else {
await bot.sendMessage(chatId, "Errore: il plugin non è accessibile per salvare la configurazione.");
}
}
}
];

67
plugin/telegram/callbacks/status.js Normal file
View File

@@ -0,0 +1,67 @@
const realtime = require('../../realtime/core.js');
module.exports = [
{
id: 'session-weather-toggle',
execute: async ({ bot, chatId, app, msg }) => {
if (!app.mebPlugin) {
return bot.answerCallbackQuery(msg.id, { text: "Errore: Plugin Meteo non caricato" });
}
let isActive = app.mebPlugin.isPollingActive();
if (isActive) {
app.mebPlugin.stopPolling();
} else {
app.mebPlugin.startPolling();
}
const sessionCmd = require('../commands/status.js');
const newMarkup = sessionCmd.createSessionMenu(app);
await bot.editMessageReplyMarkup(newMarkup.reply_markup, {
chat_id: chatId,
message_id: msg.message_id
});
}
},
{
id: 'session-realtime-info',
execute: async ({ bot, chatId, msg }) => {
const stats = realtime.getStats();
let text = `📡 *Stato Realtime*\n\n`;
text += `Stato: *${stats.status}*\n`;
text += `Sensore: \`${stats.sensorID}\`\n`;
text += `Messaggi inviati: *${stats.sent}*\n`;
text += `Buffer: ${stats.buffered} msg\n`;
text += `Riconnessioni: ${stats.reconnections}\n`;
text += `\n_I dati vengono inviati automaticamente ogni ${stats.sentEveryMLS / 1000}s_`;
await bot.answerCallbackQuery(msg.id, { text: `Realtime: ${stats.status} | ${stats.sent} msg inviati` });
}
},
{
id: 'session-refresh',
execute: async ({ bot, chatId, app, msg }) => {
const sessionCmd = require('../commands/status.js');
const newMarkup = sessionCmd.createSessionMenu(app);
const now = new Date().toLocaleTimeString('it-IT');
const newText = `*Servizi*\n\n_(Ultimo aggiornamento: ${now})_`;
try {
await bot.editMessageText(newText, {
chat_id: chatId,
message_id: msg.message_id,
parse_mode: 'Markdown',
reply_markup: newMarkup.reply_markup
});
} catch (e) {
if (!e.message.includes('message is not modified')) {
console.error("Errore nel refresh session:", e);
}
}
}
}
];

26
plugin/telegram/callbacks/weather.js Normal file
View File

@@ -0,0 +1,26 @@
module.exports = [
{
id: 'weather-refresh',
execute: async ({ bot, chatId, msg }) => {
const weather = require('../commands/weather.js');
const newText = weather.formatWeatherData();
try {
await bot.editMessageText(newText, {
chat_id: chatId,
message_id: msg.message_id,
parse_mode: 'Markdown',
reply_markup: {
inline_keyboard: [
[{ text: 'Aggiorna', callback_data: 'weather-refresh' }]
]
}
});
} catch (e) {
if (!e.message.includes('message is not modified')) {
console.error('[Telegram Weather] Errore refresh:', e.message);
}
}
}
}
];