1068 lines
37 KiB
JavaScript
1068 lines
37 KiB
JavaScript
const TelegramBot = require('node-telegram-bot-api');
|
|
const ping = require('ping');
|
|
const os = require('os');
|
|
const fs = require('fs');
|
|
const yaml = require('js-yaml');
|
|
require('dotenv').config();
|
|
const serverNotificationState = {};
|
|
const logDirectory = 'logs/';
|
|
let usersAddingServer = {};
|
|
let isShowingDetails = false;
|
|
const botStartTime = new Date();
|
|
const { promisify } = require('util');
|
|
const exec = promisify(require('child_process').exec);
|
|
|
|
|
|
const developerChatIds = process.env.DEVELOPER_CHAT_IDS.split(',');
|
|
const token = process.env.TELEGRAM_BOT_TOKEN;
|
|
const tgId = process.env.TG_ID;
|
|
const bot = new TelegramBot(token, { polling: true });
|
|
|
|
|
|
if (!tgId) {
|
|
const errorMessage = 'Fehler: Die ID wurde geändert. Der Bot wird nicht gestartet.';
|
|
console.error(errorMessage);
|
|
sendErrorNotification(developerChatIds[0], errorMessage);
|
|
process.exit(1);
|
|
}
|
|
|
|
|
|
if (tgId !== '5507179337') {
|
|
const errorMessage = 'Fehler: Der Bot wird nicht gestartet.';
|
|
console.error(errorMessage);
|
|
sendErrorNotification(developerChatIds[0], errorMessage);
|
|
process.exit(1);
|
|
}
|
|
|
|
|
|
function isDeveloperChat(chatId) {
|
|
return developerChatIds.includes(chatId.toString());
|
|
}
|
|
|
|
const activeUserIds = new Set();
|
|
|
|
const monitoredServers = [];
|
|
|
|
// Lese die Konfigurationsdatei
|
|
try {
|
|
const configContent = fs.readFileSync('configurations.yml', 'utf8');
|
|
const config = yaml.load(configContent);
|
|
|
|
// Überprüfe, ob es eine Server-Konfiguration gibt
|
|
if (config) {
|
|
// Füge die überwachten Server zur Liste hinzu
|
|
Object.values(config).forEach(serverList => {
|
|
monitoredServers.push(...serverList);
|
|
});
|
|
}
|
|
} catch (error) {
|
|
console.error('Fehler beim Lesen der Konfigurationsdatei:', error.message);
|
|
}
|
|
|
|
// Event-Handler für den Befehl /stats
|
|
bot.onText(/\/stats/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
if (isDeveloperChat(chatId)) {
|
|
if (!activeUserIds.has(chatId)) {
|
|
activeUserIds.add(chatId);
|
|
}
|
|
|
|
try {
|
|
// Gesamtanzahl der überwachten Server
|
|
const serverCount = getServerCount(); // Funktion, die die Anzahl der überwachten Server zurückgibt
|
|
|
|
// Anzahl der Fehler im error.log
|
|
const errorCount = getErrorCount(); // Funktion, die die Anzahl der Fehler im error.log zurückgibt
|
|
|
|
// Bot Uptime in Stunden
|
|
const uptime = getBotUptime(); // Funktion, die die Bot-Uptime in Stunden zurückgibt
|
|
|
|
// Anzahl der Benutzer, die diesen Bot nutzen
|
|
const totalUserCount = getTotalUserCount();
|
|
|
|
// Version des Telegram Bot API-Pakets
|
|
const telegramBotApiVersion = getTelegramBotApiVersion();
|
|
|
|
// Nachricht mit den Statistiken senden
|
|
bot.sendMessage(chatId, `
|
|
*Statistik*
|
|
Gesamtanzahl der überwachten Server: ${serverCount}
|
|
Anzahl der Fehler im error.log: ${errorCount}
|
|
Bot Uptime: ${uptime.days} Tage, ${uptime.hours} Stunden und ${uptime.minutes} Minuten
|
|
Anzahl der Benutzer: ${totalUserCount}
|
|
Telegram Bot API-Version: ${telegramBotApiVersion}
|
|
`);
|
|
} catch (error) {
|
|
console.error('Fehler beim Abrufen der Statistiken:', error.message);
|
|
bot.sendMessage(chatId, 'Fehler beim Abrufen der Statistiken. Bitte versuche es später erneut.');
|
|
}
|
|
} else {
|
|
bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler');
|
|
}
|
|
});
|
|
|
|
// Funktion, um die Anzahl der überwachten Server zu erhalten
|
|
function getServerCount() {
|
|
return monitoredServers.length;
|
|
}
|
|
|
|
// Funktion, um die Anzahl der Fehler im error.log zu erhalten
|
|
function getErrorCount() {
|
|
try {
|
|
const errorLogContent = fs.readFileSync('error.log', 'utf8');
|
|
const errorLines = errorLogContent.split('\n');
|
|
return errorLines.length;
|
|
} catch (error) {
|
|
console.error('Fehler beim Lesen der error.log-Datei:', error.message);
|
|
return 'Fehler beim Lesen der Log-Datei';
|
|
}
|
|
}
|
|
|
|
// Funktion, um die Bot-Uptime in Tagen, Stunden und Minuten zu erhalten
|
|
function getBotUptime() {
|
|
const uptimeMilliseconds = new Date() - botStartTime; // botStartTime sollte irgendwo definiert und beim Bot-Start festgelegt sein
|
|
|
|
// Berechne Tage, Stunden und Minuten
|
|
const days = Math.floor(uptimeMilliseconds / (1000 * 60 * 60 * 24));
|
|
const hours = Math.floor((uptimeMilliseconds % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
|
|
const minutes = Math.floor((uptimeMilliseconds % (1000 * 60 * 60)) / (1000 * 60));
|
|
|
|
return { days, hours, minutes };
|
|
}
|
|
|
|
|
|
// Pfad zur user_information.yml
|
|
const userInformationPath = 'user_information.yml';
|
|
|
|
// Funktion, um die Gesamtanzahl der Benutzer-IDs in der user_information.yml zu erhalten
|
|
function getTotalUserCount() {
|
|
try {
|
|
// Lese den Inhalt der Datei
|
|
const userInformationContent = fs.readFileSync(userInformationPath, 'utf8');
|
|
|
|
// Parsen des YAML-Inhalts
|
|
const userInformation = yaml.load(userInformationContent);
|
|
|
|
// Prüfe, ob die Benutzerinformation ein Objekt ist
|
|
if (typeof userInformation === 'object' && userInformation !== null) {
|
|
// Zähle die Gesamtanzahl der Benutzer-IDs
|
|
const totalUserCount = Object.keys(userInformation).length;
|
|
return `${totalUserCount}`;
|
|
} else {
|
|
console.error('Ungültiges Format der Benutzerinformation.');
|
|
return 'Fehler bei der Verarbeitung der Benutzerinformation';
|
|
}
|
|
} catch (error) {
|
|
console.error('Fehler beim Lesen der Benutzerinformation:', error.message);
|
|
return 'Fehler beim Lesen der Benutzerinformation';
|
|
}
|
|
}
|
|
|
|
// Beispielaufruf
|
|
console.log(getTotalUserCount());
|
|
|
|
// Funktion, um die Version des Telegram Bot API-Pakets zu erhalten
|
|
function getTelegramBotApiVersion() {
|
|
try {
|
|
// Lese den Inhalt der package.json-Datei
|
|
const packageJsonContent = fs.readFileSync('package.json', 'utf8');
|
|
|
|
// Parsen des JSON-Inhalts
|
|
const packageJson = JSON.parse(packageJsonContent);
|
|
|
|
// Gib die Version des Telegram Bot API-Pakets zurück
|
|
return packageJson.dependencies['node-telegram-bot-api'];
|
|
} catch (error) {
|
|
console.error('Fehler beim Lesen der package.json-Datei:', error.message);
|
|
return 'Fehler beim Lesen der package.json-Datei';
|
|
}
|
|
}
|
|
|
|
// Funktion zum Speichern von Benutzerinformationen
|
|
function saveUserInformation(userId, username) {
|
|
try {
|
|
let userInformation = {};
|
|
|
|
if (fs.existsSync(userInformationPath)) {
|
|
const data = fs.readFileSync(userInformationPath, 'utf8');
|
|
userInformation = yaml.load(data) || {};
|
|
}
|
|
|
|
userInformation[`user${userId}`] = {
|
|
id: userId,
|
|
name: username
|
|
};
|
|
|
|
const yamlString = yaml.dump(userInformation);
|
|
fs.writeFileSync(userInformationPath, yamlString, 'utf8');
|
|
} catch (error) {
|
|
console.error('Fehler beim Speichern von Benutzerinformationen:', error.message);
|
|
}
|
|
}
|
|
|
|
// Funktion zum Initialisieren beim Start des Bots
|
|
function initialize() {
|
|
// Stelle sicher, dass die Datei existiert oder erstelle sie
|
|
const userInformationPath = 'user_information.yml';
|
|
|
|
if (!fs.existsSync(userInformationPath)) {
|
|
fs.writeFileSync(userInformationPath, '', 'utf8');
|
|
}
|
|
}
|
|
|
|
// Rufe die Initialisierungsfunktion auf
|
|
initialize();
|
|
|
|
bot.onText(/\/user_id/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
// Überprüfen, ob der Benutzer Entwickler ist
|
|
if (!isDeveloperChat(chatId)) {
|
|
bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler.');
|
|
return;
|
|
}
|
|
|
|
try {
|
|
// Lade Benutzerinformationen aus der user_information.yml-Datei
|
|
const userInformation = loadUserInformation();
|
|
|
|
// Überprüfen, ob Benutzerinformationen vorhanden sind
|
|
if (Object.keys(userInformation).length === 0) {
|
|
bot.sendMessage(chatId, 'Keine Benutzerinformationen gefunden.');
|
|
return;
|
|
}
|
|
|
|
// Konvertiere Benutzerinformationen in eine Liste von Benutzernamen und IDs
|
|
const userList = Object.keys(userInformation).map(key => {
|
|
const user = userInformation[key];
|
|
return `${user.name} - ${user.id}`;
|
|
});
|
|
|
|
// Sende die Liste der Benutzerinformationen
|
|
bot.sendMessage(chatId, 'Benutzerinformationen:\n' + userList.join('\n'));
|
|
} catch (error) {
|
|
console.error('Fehler beim Abrufen von Benutzerinformationen:', error.message);
|
|
bot.sendMessage(chatId, 'Fehler beim Abrufen von Benutzerinformationen.');
|
|
}
|
|
});
|
|
|
|
function loadUserInformation() {
|
|
try {
|
|
const userInformationPath = './user_information.yml';
|
|
const data = fs.readFileSync(userInformationPath, 'utf8');
|
|
return yaml.load(data) || {};
|
|
} catch (error) {
|
|
console.error('Fehler beim Laden der Benutzerinformationen:', error.message);
|
|
return {};
|
|
}
|
|
}
|
|
|
|
// Event-Handler für das Hinzufügen und Entfernen von Benutzern
|
|
bot.on('message', (msg) => {
|
|
const chatId = msg.chat.id;
|
|
const userId = msg.from.id;
|
|
|
|
// Überprüfe, ob die Benutzer-ID bereits gespeichert wurde
|
|
if (!activeUserIds.has(chatId)) {
|
|
activeUserIds.add(chatId);
|
|
|
|
// Speichere Benutzerinformationen
|
|
saveUserInformation(userId.toString(), `@${msg.from.username}`);
|
|
}
|
|
|
|
if (!activeUserIds.has(chatId)) {
|
|
activeUserIds.add(chatId);
|
|
}
|
|
});
|
|
|
|
bot.on('polling_error', (error) => {
|
|
console.error(`Polling error: ${error.message}`);
|
|
});
|
|
|
|
function escapeMarkdown(text) {
|
|
|
|
return text.replace(/[_*[\]()~`>#+-=|{}.!]/g, '\\$&');
|
|
}
|
|
|
|
function getBotInfo() {
|
|
const botInfo = {
|
|
name: 'Server Monitoring',
|
|
version: '1.0.0',
|
|
author: 'M_Viper',
|
|
license: 'MIT',
|
|
};
|
|
|
|
|
|
const infoMessage = `
|
|
Bot Information:
|
|
- *Name:* ${escapeMarkdown(botInfo.name)}
|
|
- *Version:* ${escapeMarkdown(botInfo.version)}
|
|
- *Author:* ${escapeMarkdown(botInfo.author)}
|
|
- *License:* ${escapeMarkdown(botInfo.license)}
|
|
Bot wurde am 22.01.2024 erstellt.
|
|
`;
|
|
|
|
console.log(infoMessage);
|
|
|
|
return infoMessage;
|
|
}
|
|
|
|
bot.onText(/\/user_id (.+)/, (msg, match) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
// Überprüfen, ob der Benutzer Entwickler ist
|
|
if (!isDeveloperChat(chatId)) {
|
|
bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler.');
|
|
return;
|
|
}
|
|
|
|
const targetUsername = match[1];
|
|
|
|
// Überprüfen, ob der Benutzer existiert
|
|
bot.getChat(targetUsername)
|
|
.then(user => {
|
|
const userId = user.id;
|
|
bot.sendMessage(chatId, `Die ID des Benutzers @${targetUsername} ist: ${userId}`);
|
|
})
|
|
.catch(error => {
|
|
bot.sendMessage(chatId, `Der Benutzer @${targetUsername} existiert nicht.`);
|
|
});
|
|
});
|
|
|
|
bot.onText(/\/user_delete (.+)/, (msg, match) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
// Überprüfen, ob der Benutzer Entwickler ist
|
|
if (!isDeveloperChat(chatId)) {
|
|
bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler.');
|
|
return;
|
|
}
|
|
|
|
const targetUserId = match[1];
|
|
|
|
// Überprüfen, ob der Benutzer existiert und Server hinzugefügt hat
|
|
if (!targetUserId || !userServerConfigurations[targetUserId]) {
|
|
bot.sendMessage(chatId, `Der Benutzer mit ID ${targetUserId} existiert nicht oder hat keine Server hinzugefügt.`);
|
|
return;
|
|
}
|
|
|
|
// Lösche alle Server des Zielbenutzers
|
|
delete userServerConfigurations[targetUserId];
|
|
saveConfigurations(userServerConfigurations);
|
|
|
|
bot.sendMessage(chatId, `Alle Server des Benutzers mit ID ${targetUserId} wurden gelöscht.`);
|
|
});
|
|
|
|
bot.onText(/\/info/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
const infoMessage = getBotInfo();
|
|
|
|
const options = {
|
|
parse_mode: 'Markdown',
|
|
};
|
|
|
|
bot.sendMessage(chatId, infoMessage, options);
|
|
});
|
|
|
|
// Event-Handler für den Befehl /log_clear
|
|
bot.onText(/\/error_clear/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
// Überprüfen, ob die Chat-ID des Benutzers in den Developer-Chat-IDs enthalten ist
|
|
if (!isDeveloperChat(chatId)) {
|
|
bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler');
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const logFileName = 'error.log';
|
|
const logFilePath = logFileName; // Pfade im gleichen Verzeichnis
|
|
|
|
// Lösche den Inhalt des Logfiles
|
|
fs.writeFileSync(logFilePath, '');
|
|
|
|
bot.sendMessage(chatId, 'Der Log-Inhalt wurde erfolgreich gelöscht.');
|
|
} catch (error) {
|
|
console.error(`Fehler beim Löschen des Log-Inhalts: ${error.message}`);
|
|
bot.sendMessage(chatId, 'Fehler beim Löschen des Log-Inhalts.');
|
|
}
|
|
});
|
|
|
|
// Event-Handler für den Befehl /error_send
|
|
bot.onText(/\/error_send/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
// Überprüfen, ob die Chat-ID des Benutzers in den Developer-Chat-IDs enthalten ist
|
|
if (!isDeveloperChat(chatId)) {
|
|
bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler');
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const logFileName = 'error.log';
|
|
const logFilePath = logFileName; // Pfade im gleichen Verzeichnis
|
|
|
|
// Überprüfe, ob die Logdatei existiert
|
|
if (fs.existsSync(logFilePath)) {
|
|
// Sende die Logdatei als Dokument an den Entwickler
|
|
bot.sendDocument(chatId, logFilePath);
|
|
} else {
|
|
bot.sendMessage(chatId, `Die Logdatei ${logFileName} existiert nicht.`);
|
|
}
|
|
} catch (error) {
|
|
console.error(`Fehler beim Senden der Logdatei: ${error.message}`);
|
|
bot.sendMessage(chatId, 'Fehler beim Senden der Logdatei.');
|
|
}
|
|
});
|
|
|
|
// Füge diese Funktion hinzu, um Fehlerbenachrichtigungen und das Protokoll zu handhaben
|
|
bot.on('polling_error', (error) => {
|
|
console.error(`Polling error: ${error.message}`);
|
|
sendErrorNotification(developerChatIds, `Polling error: ${error.message}`);
|
|
});
|
|
|
|
process.on('unhandledRejection', (reason, promise) => {
|
|
console.error('Unhandled rejection:', reason);
|
|
sendErrorNotification(developerChatIds, `Unhandled rejection: ${reason}`);
|
|
});
|
|
|
|
process.on('uncaughtException', (error) => {
|
|
console.error('Uncaught exception:', error);
|
|
sendErrorNotification(developerChatIds, `Uncaught exception: ${error}`);
|
|
});
|
|
|
|
// Füge diese Funktion hinzu, um Fehlerbenachrichtigungen und das Protokoll zu handhaben
|
|
bot.on('polling_error', (error) => {
|
|
console.error(`Polling error: ${error.message}`);
|
|
sendErrorNotification(developerChatIds, `Polling error: ${error.message}`);
|
|
});
|
|
|
|
process.on('unhandledRejection', (reason, promise) => {
|
|
console.error('Unhandled rejection:', reason);
|
|
sendErrorNotification(developerChatIds, `Unhandled rejection: ${reason}`);
|
|
});
|
|
|
|
process.on('uncaughtException', (error) => {
|
|
console.error('Uncaught exception:', error);
|
|
sendErrorNotification(developerChatIds, `Uncaught exception: ${error}`);
|
|
});
|
|
|
|
// Funktion zum Senden von Fehlerbenachrichtigungen und Erstellen des Fehlerprotokolls
|
|
function sendErrorNotification(chatId, errorMessage) {
|
|
const errorNotification = `❗️ *Fehler im Bot:*\n\n\`\`\`${errorMessage}\`\`\``;
|
|
|
|
bot.sendMessage(chatId, errorNotification, { parse_mode: 'Markdown' });
|
|
|
|
// Fehlerprotokoll erstellen
|
|
const logFilePath = 'error.log';
|
|
const formattedDate = new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
|
|
const logEntry = `[${formattedDate}] ${errorMessage}\n`;
|
|
|
|
fs.appendFile(logFilePath, logEntry, (err) => {
|
|
if (err) {
|
|
console.error(`Fehler beim Schreiben in das Fehlerprotokoll: ${err.message}`);
|
|
}
|
|
});
|
|
}
|
|
|
|
const errorLogPath = 'error.log';
|
|
fs.openSync(errorLogPath, 'a');
|
|
|
|
bot.onText(/\/error/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
// Überprüfen, ob die Chat-ID des Benutzers in den Developer-Chat-IDs enthalten ist
|
|
if (!isDeveloperChat(chatId)) {
|
|
bot.sendMessage(chatId, 'Dieser Befehl ist nur für Entwickler');
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const logFileName = 'error.log';
|
|
const logFilePath = logDirectory + logFileName;
|
|
|
|
if (fs.existsSync(logFilePath)) {
|
|
const logContent = fs.readFileSync(logFilePath, 'utf8');
|
|
const logEntries = logContent.split('\n').filter(entry => entry.trim() !== '').slice(-8);
|
|
|
|
if (logEntries.length > 0) {
|
|
const logMessage = `Die letzten 8 Fehlerprotokolle:\n\n${logEntries.join('\n')}`;
|
|
bot.sendMessage(chatId, logMessage);
|
|
} else {
|
|
bot.sendMessage(chatId, 'Keine Fehlerprotokolle vorhanden.');
|
|
}
|
|
} else {
|
|
bot.sendMessage(chatId, 'Kein Fehlerprotokoll vorhanden. Es wurden noch keine Fehler protokolliert.');
|
|
}
|
|
} catch (error) {
|
|
console.error(`Fehler beim Lesen des Fehlerprotokolls: ${error.message}`);
|
|
bot.sendMessage(chatId, 'Fehler beim Lesen des Fehlerprotokolls.');
|
|
}
|
|
});
|
|
|
|
|
|
function createLogEntry(action, serverName, serverAddress) {
|
|
const currentDate = new Date();
|
|
const formattedDate = currentDate.toISOString().replace(/T/, ' ').replace(/\..+/, '');
|
|
|
|
const logEntry = `[${formattedDate}] Action: ${action}, Server Name: ${serverName}, Server Address: ${serverAddress}\n`;
|
|
|
|
return logEntry;
|
|
}
|
|
|
|
function writeToLog(userId, logEntry) {
|
|
const logFileName = `user_${userId}_log.txt`;
|
|
const logFilePath = logDirectory + logFileName;
|
|
|
|
try {
|
|
if (!fs.existsSync(logDirectory)) {
|
|
fs.mkdirSync(logDirectory);
|
|
}
|
|
|
|
// Lese vorhandene Logeinträge
|
|
let existingLogEntries = [];
|
|
if (fs.existsSync(logFilePath)) {
|
|
const existingLogContent = fs.readFileSync(logFilePath, 'utf8');
|
|
existingLogEntries = existingLogContent.split('\n').filter(entry => entry.trim() !== '');
|
|
}
|
|
|
|
// Füge neuen Eintrag hinzu
|
|
existingLogEntries.push(logEntry);
|
|
|
|
// Entferne Einträge älter als 7 Tage
|
|
const currentTime = Date.now();
|
|
const sevenDaysAgo = currentTime - 7 * 24 * 60 * 60 * 1000;
|
|
existingLogEntries = existingLogEntries.filter(entry => {
|
|
const entryTimestamp = new Date(entry.split(']')[0].replace('[', '')).getTime();
|
|
return entryTimestamp >= sevenDaysAgo;
|
|
});
|
|
|
|
// Schreibe die neuen Logeinträge
|
|
fs.writeFileSync(logFilePath, existingLogEntries.join('\n'), 'utf8');
|
|
} catch (error) {
|
|
console.error(`Fehler beim Schreiben des Logs: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
let userServerConfigurations = loadConfigurations();
|
|
const chatIds = new Set();
|
|
|
|
function loadConfigurations() {
|
|
try {
|
|
if (fs.existsSync('configurations.yml')) {
|
|
const data = fs.readFileSync('configurations.yml', 'utf8');
|
|
return yaml.load(data) || {};
|
|
} else {
|
|
saveConfigurations({});
|
|
return {};
|
|
}
|
|
} catch (error) {
|
|
console.error('Fehler beim Laden der Konfigurationen:', error.message);
|
|
return {};
|
|
}
|
|
}
|
|
|
|
function saveConfigurations(configurations) {
|
|
try {
|
|
const yamlString = yaml.dump(configurations);
|
|
fs.writeFileSync('configurations.yml', yamlString, 'utf8');
|
|
} catch (error) {
|
|
console.error('Fehler beim Speichern der Konfigurationen:', error.message);
|
|
}
|
|
}
|
|
|
|
function getCpuUsage() {
|
|
return Math.floor(Math.random() * 101);
|
|
}
|
|
|
|
function getRamUsage() {
|
|
return Math.floor(Math.random() * 101);
|
|
}
|
|
|
|
function getNetworkTraffic() {
|
|
return Math.floor(Math.random() * 101);
|
|
}
|
|
|
|
async function getUptime() {
|
|
const uptimeInSeconds = os.uptime();
|
|
const days = Math.floor(uptimeInSeconds / (24 * 3600));
|
|
const hours = Math.floor((uptimeInSeconds % (24 * 3600)) / 3600);
|
|
const minutes = Math.floor((uptimeInSeconds % 3600) / 60);
|
|
return `${days} Tage, ${hours} Stunden, ${minutes} Minuten`;
|
|
}
|
|
|
|
async function checkServerStatus(serverAddress) {
|
|
try {
|
|
const result = await ping.promise.probe(serverAddress);
|
|
return result.alive ? 'Online' : 'Offline';
|
|
} catch (error) {
|
|
console.error(`Fehler beim Überprüfen des Servers ${serverAddress}: ${error.message}`);
|
|
return 'Fehler';
|
|
}
|
|
}
|
|
|
|
const onlineIcon = '✅';
|
|
const offlineIcon = '❌';
|
|
const errorIcon = '⚠️';
|
|
const bannerEmoji = '🚀';
|
|
|
|
|
|
|
|
|
|
|
|
function sendStatusMessage(chatId, serverName, serverStatus) {
|
|
const statusIcon = serverStatus === 'Online' ? onlineIcon : offlineStatus === 'Offline' ? offlineIcon : errorIcon;
|
|
|
|
const statusMessage = `Server ${bannerEmoji}${serverName}${bannerEmoji} ist ${statusIcon} ${serverStatus}.`;
|
|
|
|
bot.sendMessage(chatId, statusMessage);
|
|
}
|
|
|
|
// Funktion, um die Bot-Uptime in Tagen, Stunden und Minuten zu erhalten
|
|
function getBotUptime() {
|
|
const uptimeMilliseconds = new Date() - botStartTime; // botStartTime sollte irgendwo definiert und beim Bot-Start festgelegt sein
|
|
|
|
// Berechne Tage, Stunden und Minuten
|
|
const days = Math.floor(uptimeMilliseconds / (1000 * 60 * 60 * 24));
|
|
const hours = Math.floor((uptimeMilliseconds % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
|
|
const minutes = Math.floor((uptimeMilliseconds % (1000 * 60 * 60)) / (1000 * 60));
|
|
|
|
return { days, hours, minutes };
|
|
}
|
|
|
|
bot.onText(/\/uptime/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
const { days, hours, minutes } = getBotUptime();
|
|
bot.sendMessage(chatId, `Bot Uptime: ${days} Tage, ${hours} Stunden und ${minutes} Minuten`);
|
|
});
|
|
|
|
bot.onText(/\/start/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
// Überprüfen, ob der Befehl /start_notifications verwendet wurde
|
|
if (!msg.text.includes('/start_notifications')) {
|
|
// Senden Sie die Nachricht nur, wenn der Befehl /start_notifications nicht verwendet wurde
|
|
bot.sendMessage(chatId, 'Bot gestartet. Benutze /add_server, /delete_server, /status und /help für die Serververwaltung.');
|
|
}
|
|
|
|
chatIds.add(chatId);
|
|
});
|
|
|
|
bot.onText(/\/start_notifications/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
startNotifications(chatId);
|
|
});
|
|
|
|
function startNotifications(chatId) {
|
|
const userServers = userServerConfigurations[chatId] || [];
|
|
|
|
if (userServers.length === 0) {
|
|
bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
|
|
return;
|
|
}
|
|
|
|
userServers.forEach(serverConfig => {
|
|
const serverAddress = serverConfig.address;
|
|
serverNotificationState[serverAddress] = true;
|
|
});
|
|
|
|
bot.sendMessage(chatId, 'Benachrichtigungen für alle Server wurden aktiviert.');
|
|
}
|
|
|
|
bot.onText(/\/stop_notifications/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
stopNotifications(chatId);
|
|
});
|
|
|
|
function stopNotifications(chatId) {
|
|
const userServers = userServerConfigurations[chatId] || [];
|
|
|
|
if (userServers.length === 0) {
|
|
bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
|
|
return;
|
|
}
|
|
|
|
userServers.forEach(serverConfig => {
|
|
const serverAddress = serverConfig.address;
|
|
serverNotificationState[serverAddress] = false;
|
|
});
|
|
|
|
bot.sendMessage(chatId, 'Benachrichtigungen für alle Server wurden deaktiviert.');
|
|
}
|
|
|
|
bot.onText(/\/status/, async (msg) => {
|
|
const chatId = msg.chat.id;
|
|
const userServers = userServerConfigurations[chatId] || [];
|
|
|
|
if (userServers.length === 0) {
|
|
bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
|
|
return;
|
|
}
|
|
|
|
let statusMessage = 'Server Status:\n';
|
|
|
|
for (const serverConfig of userServers) {
|
|
const serverName = serverConfig.name;
|
|
const serverAddress = serverConfig.address;
|
|
|
|
try {
|
|
const serverStatus = await checkServerStatus(serverAddress);
|
|
|
|
const statusIcon = serverStatus === 'Online' ? '✅' : serverStatus === 'Offline' ? '❌' : '⚠️';
|
|
const notificationEnabled = serverNotificationState[serverAddress];
|
|
|
|
statusMessage += `
|
|
*Server:* ${bannerEmoji}${serverName}${bannerEmoji} ${statusIcon} ${serverStatus}
|
|
*Benachrichtigungen:* ${notificationEnabled ? 'Aktiviert' : 'Deaktiviert'}
|
|
\n`;
|
|
} catch (error) {
|
|
console.error(`Fehler beim Überprüfen des Servers ${serverName}: ${error.message}`);
|
|
statusMessage += `Fehler beim Überprüfen des Servers ${bannerEmoji}${serverName}${bannerEmoji}. ${errorIcon}\n`;
|
|
}
|
|
}
|
|
|
|
// Füge hier den Benachrichtigungsstatus direkt unterhalb der Serverliste hinzu
|
|
const notificationStatusMessage = 'Benachrichtigungen für alle Server sind ' +
|
|
(Object.values(serverNotificationState).every((status) => status) ? 'aktiviert.' : 'deaktiviert.');
|
|
|
|
statusMessage += `\n${notificationStatusMessage}`;
|
|
|
|
const options = {
|
|
parse_mode: 'Markdown',
|
|
reply_markup: {
|
|
inline_keyboard: [
|
|
[{
|
|
text: 'Details',
|
|
callback_data: 'details'
|
|
}]
|
|
]
|
|
}
|
|
};
|
|
|
|
bot.sendMessage(chatId, statusMessage, options);
|
|
});
|
|
|
|
bot.onText(/\/add_server/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
bot.sendMessage(chatId, 'Füge einen neuen Server hinzu. Sende mir zuerst den Namen des Servers:');
|
|
|
|
// Verwendung der Variable usersAddingServer
|
|
usersAddingServer[chatId] = { name: null, address: null };
|
|
|
|
bot.once('text', (serverNameMsg) => {
|
|
usersAddingServer[chatId].name = serverNameMsg.text;
|
|
|
|
bot.sendMessage(chatId, `Servername ${bannerEmoji}${serverNameMsg.text}${bannerEmoji} wurde hinzugefügt. Jetzt sende mir die IP-Adresse des Servers:`);
|
|
|
|
bot.once('text', (serverAddressMsg) => {
|
|
usersAddingServer[chatId].address = serverAddressMsg.text;
|
|
|
|
userServerConfigurations[chatId] = userServerConfigurations[chatId] || [];
|
|
userServerConfigurations[chatId].push(usersAddingServer[chatId]);
|
|
|
|
saveConfigurations(userServerConfigurations);
|
|
|
|
const logEntry = createLogEntry('Add Server', usersAddingServer[chatId].name, usersAddingServer[chatId].address);
|
|
writeToLog(chatId, logEntry);
|
|
|
|
bot.sendMessage(chatId, `Server ${bannerEmoji}${usersAddingServer[chatId].name}${bannerEmoji} mit Adresse "${usersAddingServer[chatId].address}" wurde hinzugefügt.`);
|
|
});
|
|
});
|
|
});
|
|
|
|
bot.onText(/\/delete_server/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
const userServers = userServerConfigurations[chatId] || [];
|
|
|
|
if (userServers.length === 0) {
|
|
bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
|
|
return;
|
|
}
|
|
|
|
const keyboard = {
|
|
reply_markup: {
|
|
inline_keyboard: userServers.map(server => [{
|
|
text: `${server.name} - ${server.address}`,
|
|
callback_data: `delete:${server.name}:${server.address}`
|
|
}])
|
|
}
|
|
};
|
|
|
|
bot.sendMessage(chatId, 'Wähle einen Server zum Löschen aus:', keyboard);
|
|
});
|
|
|
|
bot.on('callback_query', (query) => {
|
|
const chatId = query.message.chat.id;
|
|
const [action, serverName, serverAddress] = query.data.split(':');
|
|
|
|
if (action === 'delete') {
|
|
userServerConfigurations[chatId] = (userServerConfigurations[chatId] || []).filter(server => !(server.name === serverName && server.address === serverAddress));
|
|
|
|
saveConfigurations(userServerConfigurations);
|
|
|
|
const logEntry = createLogEntry('Delete Server', serverName, serverAddress);
|
|
writeToLog(chatId, logEntry);
|
|
|
|
bot.answerCallbackQuery({ callback_query_id: query.id, text: `Server ${bannerEmoji}${serverName}${bannerEmoji} mit Adresse "${serverAddress}" wurde gelöscht.` });
|
|
} else if (action === 'stop_notifications') {
|
|
if (serverAddress) {
|
|
serverNotificationState[serverAddress] = false;
|
|
|
|
const logEntry = createLogEntry('Stop Notifications', '', serverAddress);
|
|
writeToLog(chatId, logEntry);
|
|
|
|
bot.answerCallbackQuery({ callback_query_id: query.id, text: `Benachrichtigungen für Server mit Adresse "${serverAddress}" gestoppt.` });
|
|
} else {
|
|
console.error('Ungültige Anfrage: serverAddress ist undefined.');
|
|
bot.answerCallbackQuery({ callback_query_id: query.id, text: 'Fehler: Server-Adresse ist undefiniert.' });
|
|
}
|
|
} else if (action === 'details_server') {
|
|
showServerDetails(chatId, serverName, serverAddress);
|
|
}
|
|
});
|
|
|
|
bot.onText(/\/log/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
try {
|
|
const logFileName = `user_${chatId}_log.txt`;
|
|
const logFilePath = logDirectory + logFileName;
|
|
|
|
if (fs.existsSync(logFilePath)) {
|
|
const logContent = fs.readFileSync(logFilePath, 'utf8');
|
|
const logEntries = logContent.split('\n').filter(entry => entry.trim() !== '').slice(-8);
|
|
|
|
if (logEntries.length > 0) {
|
|
const logMessage = `Die letzten 8 Logeinträge:\n\n${logEntries.join('\n')}`;
|
|
bot.sendMessage(chatId, logMessage);
|
|
} else {
|
|
bot.sendMessage(chatId, 'Keine Logeinträge vorhanden.');
|
|
}
|
|
} else {
|
|
bot.sendMessage(chatId, 'Keine Logdatei vorhanden. Führen Sie zuerst Aktionen durch, um Logeinträge zu generieren.');
|
|
}
|
|
} catch (error) {
|
|
console.error(`Fehler beim Lesen des Logs: ${error.message}`);
|
|
bot.sendMessage(chatId, 'Fehler beim Lesen des Logs.');
|
|
}
|
|
});
|
|
|
|
bot.onText(/\/save_log/, (msg) => {
|
|
console.log('In /save_log');
|
|
const chatId = msg.chat.id;
|
|
|
|
try {
|
|
const logFileName = `user_${chatId}_log.txt`;
|
|
const logFilePath = logDirectory + logFileName;
|
|
|
|
if (fs.existsSync(logFilePath)) {
|
|
// Hier direkt den Dateipfad zur Logdatei verwenden
|
|
bot.sendDocument(chatId, logFilePath, { caption: 'Hier ist Ihre Logdatei.' });
|
|
} else {
|
|
bot.sendMessage(chatId, 'Keine Logdatei vorhanden. Führen Sie zuerst Aktionen durch, um Logeinträge zu generieren.');
|
|
}
|
|
} catch (error) {
|
|
console.error(`Fehler beim Lesen des Logs: ${error.message}`);
|
|
bot.sendMessage(chatId, 'Fehler beim Lesen des Logs.');
|
|
}
|
|
});
|
|
|
|
function sendStatusNotification(chatId, serverName, serverStatus, serverAddress) {
|
|
const statusIcon = serverStatus === 'Online' ? onlineIcon : serverStatus === 'Offline' ? offlineIcon : errorIcon;
|
|
|
|
const inlineKeyboard = [[
|
|
{
|
|
text: 'Details anzeigen',
|
|
callback_data: `details_server:${serverName}:${serverAddress}`
|
|
},
|
|
|
|
]];
|
|
|
|
const options = {
|
|
parse_mode: 'Markdown',
|
|
reply_markup: {
|
|
inline_keyboard: inlineKeyboard
|
|
}
|
|
};
|
|
|
|
const notificationMessage = `Server ${bannerEmoji}${serverName}${bannerEmoji} ist ${statusIcon} ${serverStatus}. Benachrichtigungen aktiviert.`;
|
|
|
|
bot.sendMessage(chatId, notificationMessage, options);
|
|
}
|
|
|
|
function stopNotifications(chatId) {
|
|
const userServers = userServerConfigurations[chatId] || [];
|
|
|
|
if (userServers.length === 0) {
|
|
bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
|
|
return;
|
|
}
|
|
|
|
userServers.forEach(serverConfig => {
|
|
const serverAddress = serverConfig.address;
|
|
serverNotificationState[serverAddress] = false;
|
|
});
|
|
|
|
bot.sendMessage(chatId, 'Benachrichtigungen für alle Server wurden deaktiviert.');
|
|
}
|
|
|
|
async function showServerDetails(chatId, serverName, serverAddress) {
|
|
console.log(`showServerDetails called for ${serverName}`);
|
|
|
|
if (isShowingDetails) {
|
|
console.log('Details are already being shown.');
|
|
return;
|
|
}
|
|
|
|
isShowingDetails = true;
|
|
|
|
try {
|
|
const detailsMessage = `
|
|
*Details für Server ${bannerEmoji}${serverName}${bannerEmoji}*
|
|
*Uptime:* ${await getUptime()}
|
|
*CPU-Auslastung:* ${getCpuUsage()}%
|
|
*RAM-Auslastung:* ${getRamUsage()}%
|
|
*Netzwerk-Traffic:* ${getNetworkTraffic()}%
|
|
*IP/Adresse:* ${serverAddress}
|
|
`;
|
|
|
|
const options = {
|
|
parse_mode: 'Markdown',
|
|
};
|
|
|
|
await bot.sendMessage(chatId, detailsMessage, options);
|
|
} catch (error) {
|
|
console.error(`Fehler beim Anzeigen der Serverdetails: ${error.message}`);
|
|
await bot.sendMessage(chatId, 'Fehler beim Anzeigen der Serverdetails.');
|
|
} finally {
|
|
isShowingDetails = false;
|
|
}
|
|
}
|
|
|
|
bot.on('callback_query', async (query) => {
|
|
const chatId = query.message.chat.id;
|
|
const [action, ...params] = query.data.split(':');
|
|
|
|
if (action === 'details_server') {
|
|
showServerDetails(chatId, ...params);
|
|
} else {
|
|
const userServers = userServerConfigurations[chatId] || [];
|
|
|
|
if (userServers.length === 0) {
|
|
bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
|
|
return;
|
|
}
|
|
|
|
const keyboard = {
|
|
reply_markup: {
|
|
inline_keyboard: userServers.map(server => [{
|
|
text: `${server.name} - ${server.address}`,
|
|
callback_data: `details_server:${server.name}:${server.address}`
|
|
}])
|
|
}
|
|
};
|
|
|
|
bot.sendMessage(chatId, 'Wähle einen Server für Details aus:', keyboard);
|
|
}
|
|
});
|
|
|
|
|
|
|
|
bot.onText(/\/help/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
let helpMessage = `
|
|
Verfügbare Befehle:
|
|
- /add_server: Fügt einen neuen Server hinzu.
|
|
- /delete_server: Löscht einen vorhandenen Server.
|
|
- /status: Zeigt den Status der konfigurierten Server an.
|
|
- /start_notifications: Startet Benachrichtigungen für alle Server.
|
|
- /stop_notifications: Stoppt Benachrichtigungen für alle Server.
|
|
- /log: Zeigt die letzten 8 Logeinträge.
|
|
- /save_log: Speichert und sendet die letzten 8 Logeinträge als Datei.
|
|
- /uptime: Zeigt die aktuelle Betriebszeit des Bots an.
|
|
- /info: Zeigt Informationen über den Bot an.
|
|
`;
|
|
|
|
if (isDeveloperChat(chatId)) {
|
|
helpMessage += '\n\n*Entwickler Befehle:*\n' +
|
|
'- /error: Zeigt den error Log an\n' +
|
|
'- /stats: Zeigt an, wie viele Personen den Bot nutzen\n' +
|
|
'- /user_id Zeigt eine Liste von Usern an die den Bot nutzen\n' +
|
|
'- /user_delete "ID" löscht alle Server des Benutzer\n' +
|
|
'- /error_send schickt die error.log Datei\n' +
|
|
'- /error_clear löscht alle einträge im error.log';
|
|
}
|
|
|
|
bot.sendMessage(chatId, helpMessage);
|
|
});
|
|
|
|
const checkIntervalMinutes = 2;
|
|
const checkIntervalMilliseconds = checkIntervalMinutes * 60 * 1000;
|
|
|
|
const offlineNotificationIntervalMinutes = 360; // Ändern Sie nach Bedarf
|
|
const offlineNotificationIntervalMilliseconds = offlineNotificationIntervalMinutes * 60 * 1000;
|
|
|
|
const lastOfflineNotificationTime = new Map();
|
|
|
|
setInterval(async () => {
|
|
await checkAndSendServerStatus();
|
|
}, checkIntervalMilliseconds);
|
|
|
|
async function checkAndSendServerStatus() {
|
|
for (const chatId of chatIds) {
|
|
const userServers = userServerConfigurations[chatId] || [];
|
|
|
|
if (userServers.length === 0) {
|
|
bot.sendMessage(chatId, 'Du hast noch keine Server hinzugefügt. Benutze /add_server, um einen Server hinzuzufügen.');
|
|
continue;
|
|
}
|
|
|
|
for (const serverConfig of userServers) {
|
|
const serverName = serverConfig.name;
|
|
const serverAddress = serverConfig.address;
|
|
|
|
try {
|
|
const serverStatus = await checkServerStatus(serverAddress);
|
|
const offlineStatus = serverStatus === 'Offline';
|
|
|
|
if (offlineStatus) {
|
|
const statusIcon = '❌';
|
|
const notificationEnabled = serverNotificationState[serverAddress];
|
|
|
|
if (notificationEnabled) {
|
|
const lastNotificationTime = lastOfflineNotificationTime.get(serverAddress) || 0;
|
|
const currentTime = Date.now();
|
|
|
|
// Überprüfen, ob die Benachrichtigung bereits innerhalb des Intervalls gesendet wurde
|
|
if (currentTime - lastNotificationTime >= offlineNotificationIntervalMilliseconds) {
|
|
console.log(`Benachrichtigung wird gesendet für Server: ${serverName}`);
|
|
const inlineKeyboard = [];
|
|
|
|
|
|
|
|
const options = {
|
|
parse_mode: 'Markdown',
|
|
reply_markup: {
|
|
inline_keyboard: inlineKeyboard
|
|
}
|
|
};
|
|
|
|
sendStatusNotification(chatId, serverName, serverStatus, serverAddress);
|
|
lastOfflineNotificationTime.set(serverAddress, currentTime);
|
|
} else {
|
|
console.log(`Offline-Benachrichtigung für Server "${serverName}" wird aufgrund des Zeitintervalls übersprungen.`);
|
|
}
|
|
} else {
|
|
console.log(`Benachrichtigungen für Server "${serverName}" sind deaktiviert.`);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error(`Fehler beim Überprüfen des Servers ${serverName}: ${error.message}`);
|
|
}
|
|
}
|
|
}
|
|
}
|