Dateien nach "/" hochladen

This commit is contained in:
M_Viper 2025-03-08 13:27:04 +00:00
parent b54098f51a
commit 2bdb6dd6e3
2 changed files with 603 additions and 0 deletions

4
.env Normal file
View File

@ -0,0 +1,4 @@
TELEGRAM_BOT_TOKEN=BOT TOKEN
TELEGRAM_CHAT_ID=ADMIN CHAT ID
PLEX_TOKEN=PLEX TOKEN
PLEX_URL=PLEX URL

599
bot.js Normal file
View File

@ -0,0 +1,599 @@
require("dotenv").config();
const { Telegraf, Markup } = require("telegraf");
const axios = require("axios");
const express = require("express");
const path = require("path");
const fs = require("fs");
const bot = new Telegraf(process.env.TELEGRAM_BOT_TOKEN);
const app = express();
const PORT = 3000;
const PLEX_URL = process.env.PLEX_URL;
const PLEX_TOKEN = process.env.PLEX_TOKEN;
const TELEGRAM_CHAT_ID = process.env.TELEGRAM_CHAT_ID;
const monitoredUsers = new Set(["user1", "666Bong"]); // Hier die Plex-Namen eintragen
let activeSessions = new Map(); // Speichert aktive Wiedergaben
let userSessions = new Map(); // Speichert aktive Sessions pro Benutzer
let lastNotified = new Map(); // Speichert die Benachrichtigungen pro Benutzer Session
let lastNotifiedDevices = new Map(); // Speichert, ob eine Warnung für zwei Geräte bereits gesendet wurde
let userViolations = new Map(); // Speichert Verstöße für Benutzer
let bannedUsers = new Map(); // Speichert gebannte Benutzer und ihre Ban-Dauer
let whitelist = new Set(); // Set für Whitelisted Benutzer
const whitelistFile = path.join(__dirname, 'whitelist.json');
let maintenanceMode = false;
const PASSWORD = process.env.DASHBOARD_PASSWORD; // Passwort aus der .env Datei
// Statisches Dashboard im 'public' Ordner
app.use(express.static(path.join(__dirname, 'public')));
// Startseite mit Passwortabfrage
app.get("/index", (req, res) => {
res.sendFile(path.join(__dirname, 'public', 'index.html'));
});
const os = require('os');
// API-Endpunkt zum Abrufen der Statistiken
app.get('/stats', (req, res) => {
// Abrufen der Statistiken: aktive Sessions, gebannte Benutzer, Verstöße
const activeSessionsCount = getActiveSessionsCount();
const bannedUsersCount = getBannedUsersCount();
const violationsCount = getViolationsCount();
const recentActivities = getRecentActivities();
// CPU- und RAM-Nutzung
const serverCpu = getCpuUsage();
const serverRam = getRamUsage();
// Antwort als JSON
res.json({
activeSessions: activeSessionsCount,
bannedUsers: bannedUsersCount,
violations: violationsCount,
serverCpu,
serverRam,
recentActivities
});
});
// Funktion zum Abrufen der CPU-Auslastung
function getCpuUsage() {
const cpus = os.cpus();
let idle = 0;
let total = 0;
cpus.forEach(cpu => {
for (type in cpu.times) {
total += cpu.times[type];
}
idle += cpu.times.idle;
});
return Math.round(((total - idle) / total) * 100);
}
// Funktion zum Abrufen der RAM-Auslastung
function getRamUsage() {
const totalMemory = os.totalmem();
const freeMemory = os.freemem();
return Math.round(((totalMemory - freeMemory) / totalMemory) * 100);
}
// Funktion zum Abrufen der Anzahl der aktiven Sessions
function getActiveSessionsCount() {
return activeSessions.size;
}
// Funktion zum Abrufen der Anzahl gebannter Benutzer
function getBannedUsersCount() {
return bannedUsers.size;
}
// Funktion zum Abrufen der Anzahl der Verstöße
function getViolationsCount() {
return Array.from(userViolations.values()).reduce((acc, violations) => acc + violations, 0);
}
let isAutoActive = false;
function getRecentActivities() {
const autoStatus = autoMode ? 'Automatik Aktiv' : 'Automatik Nicht Aktiv';
return [
`${autoStatus}`
];
}
// Funktion zum Abrufen der aktuellen Wiedergabe
async function checkPlexActivity() {
try {
console.log("🔄 Plex-Wiedergaben werden überprüft...");
const response = await axios.get(`${PLEX_URL}/status/sessions`, {
headers: { "X-Plex-Token": PLEX_TOKEN },
});
const sessions = response.data.MediaContainer.Metadata || [];
let newActiveSessions = new Map();
let newUserSessions = new Map();
// Sammle alle Sessions für Benutzer
for (const session of sessions) {
const title = session.title;
const user = session.User?.title;
const ip = session.Player?.publicAddress || session.Player?.address || "Unbekannt";
const sessionId = session.Session?.id;
if (!sessionId || !user) continue;
newActiveSessions.set(sessionId, { title, user, ip });
if (!newUserSessions.has(user)) {
newUserSessions.set(user, []);
}
newUserSessions.get(user).push({ sessionId, title, ip });
// Wenn der Benutzer auf der Whitelist ist, überspringe weitere Prüfungen
if (isUserWhitelisted(user)) {
continue; // Verhindert die Verarbeitung des Benutzers, wenn er auf der Whitelist ist
}
// Prüfen, ob der Benutzer Accountsharing hat und mehrere Geräte verwendet
if (monitoredUsers.has(user) && newUserSessions.get(user).length > 1) {
console.log(`🚫 Accountsharing erkannt bei ${user}. Wiedergabe wird gestoppt.`);
const stopMessage = "🚫 Accountsharing verboten. Dein Stream wurde beendet.";
await stopPlaybackWithMessage(user, stopMessage);
// Verstoß zählen und ggf. sperren
let violations = userViolations.get(user) || 0;
if (violations >= 2) {
bannedUsers.set(user, Date.now());
userViolations.delete(user);
bot.telegram.sendMessage(
TELEGRAM_CHAT_ID,
`🚫 ${user} wurde aufgrund von wiederholtem Accountsharing für 3 Stunden gesperrt.`
);
} else {
userViolations.set(user, violations + 1);
bot.telegram.sendMessage(
TELEGRAM_CHAT_ID,
`⚠️ Warnung! Accountsharing erkannt. (${violations + 1}/3 Verstöße)`
);
}
}
// Wenn der Benutzer auf mehreren Geräten angemeldet ist, sende eine Warnung
if (newUserSessions.get(user).length > 1 && !lastNotifiedDevices.has(user)) {
const sessionsDetails = newUserSessions.get(user)
.map(s => `📍 **IP-Adresse:** ${s.ip}\n🎞️ **Film:** ${s.title}`)
.join("\n\n");
bot.telegram.sendMessage(
TELEGRAM_CHAT_ID,
`🚨 **Achtung! Zwei Geräte mit demselben Benutzer verbunden!**\n\n👤 **Name:** ${user} \n\n${sessionsDetails}`,
Markup.inlineKeyboard([[Markup.button.callback("🚫 Accountsharing verboten", `share_ban_${user}`)]]),
);
lastNotifiedDevices.set(user, Date.now());
}
if (!lastNotified.has(sessionId)) {
bot.telegram.sendMessage(
TELEGRAM_CHAT_ID,
`🎬 **Neue Wiedergabe erkannt!**\n\n👤 **Name:** ${user} \n📍 **IP-Adresse:** ${ip} \n🎞️ **Film:** ${title}`
);
lastNotified.set(sessionId, Date.now());
}
}
// Bereinigung der inaktiven Sessions
for (const [sessionId] of activeSessions) {
if (!newActiveSessions.has(sessionId)) {
const session = activeSessions.get(sessionId);
const user = session.user;
const userSessionsList = userSessions.get(user);
if (userSessionsList) {
const index = userSessionsList.findIndex(s => s.sessionId === sessionId);
if (index !== -1) {
userSessionsList.splice(index, 1);
if (userSessionsList.length === 0) {
userSessions.delete(user);
lastNotifiedDevices.delete(user);
}
}
}
activeSessions.delete(sessionId);
}
}
activeSessions = newActiveSessions;
userSessions = newUserSessions;
console.log("✅ Plex-Wiedergaben erfolgreich aktualisiert.");
} catch (error) {
console.error("❌ Fehler beim Abrufen der Plex-Daten:", error.message);
}
}
// Wiedergabe stoppen für alle Sessions eines Benutzers
async function stopPlaybackWithMessage(userOrSessionId, message) {
try {
const sessions = userSessions.get(userOrSessionId) || [];
for (const session of sessions) {
await axios.post(
`${PLEX_URL}/status/sessions/terminate?sessionId=${session.sessionId}&reason=${encodeURIComponent(message)}`,
null,
{
headers: { "X-Plex-Token": PLEX_TOKEN },
}
);
}
if (userSessions.has(userOrSessionId)) {
userSessions.delete(userOrSessionId);
}
if (activeSessions.has(userOrSessionId)) {
activeSessions.delete(userOrSessionId);
}
lastNotifiedDevices.delete(userOrSessionId);
return true;
} catch (error) {
console.error("❌ Fehler beim Stoppen der Wiedergabe:", error.message);
return false;
}
}
// Aktion für den "Accountsharing verboten"-Button
bot.action(/^share_ban_(\w+)$/, async (ctx) => {
const user = ctx.match[1];
if (!user) {
return ctx.reply("❌ Fehler: Benutzer nicht gefunden.");
}
// Zähle die Verstöße des Benutzers
let violations = userViolations.get(user) || 0;
if (violations >= 2) {
// Temporären Bann einführen, wenn der Benutzer 3 Verstöße hat
bannedUsers.set(user, Date.now());
userViolations.delete(user); // Verstöße zurücksetzen
ctx.reply(`🚫 ${user} wurde aufgrund von wiederholtem Accountsharing vorübergehend gesperrt. Der Bann wird in 3 Stunden aufgehoben.`);
} else {
// Ansonsten die Zahl der Verstöße erhöhen
userViolations.set(user, violations + 1);
ctx.reply(`⚠️ Warnung! Accountsharing erkannt. (${violations + 1}/3 Verstöße)`);
}
const responseText = "🚫 Accountsharing ist nicht erlaubt. Zugriff verweigert.";
const success = await stopPlaybackWithMessage(user, responseText);
if (success) {
ctx.reply(`✅ Alle Streams von ${user} wurden gestoppt und die Nachricht "Accountsharing verboten" wurde gesendet.`);
} else {
ctx.reply("❌ Fehler beim Stoppen der Wiedergabe.");
}
});
// **Neuer Befehl /reload für manuelle Prüfung**
bot.command("reload", async (ctx) => {
ctx.reply("🔄 Wiedergaben werden erneut überprüft...");
await checkPlexActivity();
ctx.reply("✅ Überprüfung abgeschlossen.");
});
// **Geplante Neustarts und Wartungsmodus**
bot.command('maintenance', async (ctx) => {
if (maintenanceMode) {
return ctx.reply('🚨 Wartungsmodus ist bereits aktiviert.');
}
maintenanceMode = true;
ctx.reply('🔧 Wartungsmodus aktiviert. Alle weiteren Aktivitäten werden angehalten.');
});
bot.command('end_maintenance', async (ctx) => {
if (!maintenanceMode) {
return ctx.reply('🚨 Wartungsmodus ist derzeit nicht aktiv.');
}
maintenanceMode = false;
ctx.reply('✅ Wartungsmodus beendet. Alle Aktivitäten sind wieder normal.');
});
// **Geräteverwaltung**
bot.command('devices', async (ctx) => {
const activeDeviceList = Array.from(activeSessions.values())
.map(s => `📱 **Gerät:** ${s.title}, **IP:** ${s.ip}`);
if (activeDeviceList.length === 0) {
return ctx.reply('❌ Keine Geräte aktuell verbunden.');
}
const deviceListMessage = '🔌 **Aktuelle Geräte:**\n' + activeDeviceList.join('\n');
ctx.reply(deviceListMessage);
});
// Unban-Befehl zum Aufheben des Banns
bot.command('unban', async (ctx) => {
const user = ctx.message.text.split(' ')[1];
if (!user) {
return ctx.reply('❌ Bitte gib den Namen des Benutzers an, den du entbannen möchtest.');
}
// Überprüfen, ob der Benutzer gebannt ist
if (!bannedUsers.has(user)) {
return ctx.reply(`❌ Benutzer ${user} ist derzeit nicht gebannt.`);
}
// Bann aufheben
bannedUsers.delete(user);
ctx.reply(`✅ Der Bann für ${user} wurde erfolgreich aufgehoben. Der Benutzer kann wieder auf Plex zugreifen.`);
});
// Hilfe-Befehl
bot.command('help', async (ctx) => {
const helpMessage = `
🤖 **Telegram Plex Bot Hilfe**
**Verfügbare Befehle:**
/reload - Führt eine manuelle Prüfung aller aktiven Wiedergaben durch.\n
/stats - Zeigt Statistiken zu aktiven Sessions, gebannten Benutzern, Verstöße und Whitelist-Nutzer.\n
/whitelist <Benutzername> - Fügt einen Benutzer zur Whitelist hinzu (verhindert Accountsharing-Überprüfung).\n
/remove_whitelist <Benutzername> - Entfernt einen Benutzer von der Whitelist.\n
/unban <Benutzername> - Hebt den Bann für einen Benutzer auf.\n
/multiple_devices - Zeigt Benutzer mit mehreren Geräten an.\n
/server_status - Prüft den Status des Plex-Servers.\n
/stats - Zeigt eine Zusammenfassung der aktuellen Plex-Nutzung, einschließlich aktiver Sessions und Verstöße.\n
/help - Zeigt diese Hilfe-Nachricht an.\n
**Wichtige Hinweise:**\n
- Der Bot überprüft regelmäßig alle aktiven Plex-Wiedergaben.\n
- Wird Accountsharing festgestellt, sendet der Bot eine Warnung an den Administrator.\n
- Bei wiederholtem Accountsharing wird der Benutzer temporär gesperrt.\n
- Nur Benutzer, die nicht auf der Whitelist sind, werden überprüft.\n
- Der Bot sendet tägliche Zusammenfassungen der gesperrten Benutzer und anderer relevanter Informationen.\n
`;
await ctx.reply(helpMessage);
});
bot.command('multiple_devices', async (ctx) => {
const multipleDevicesUsers = Array.from(userSessions.entries())
.filter(([user, sessions]) => sessions.length > 1)
.map(([user, sessions]) => `${user}: ${sessions.length} Geräte`);
if (multipleDevicesUsers.length === 0) {
return ctx.reply('❌ Keine Benutzer mit mehreren Geräten gefunden.');
}
const message = '📱 Benutzer mit mehreren Geräten:\n' + multipleDevicesUsers.join('\n');
ctx.reply(message);
});
setInterval(async () => {
const bannedUsersList = Array.from(bannedUsers.keys()).join(', ');
const whitelistedUsersList = Array.from(whitelist).join(', ');
const violationsCount = getViolationsCount();
const autoModeStatus = isAutoActive ? 'Automatik Aktiv' : 'Automatik Nicht Aktiv';
const statsMessage = `
📅 **Tägliche Zusammenfassung:**
- **Aktuell gesperrte Benutzer:** ${bannedUsersList || 'Keine'}
- **Whitelisted Benutzer:** ${whitelistedUsersList || 'Keine'}
- **Verstöße insgesamt:** ${violationsCount}
- **Automatikmodus:** ${autoModeStatus}
`;
bot.telegram.sendMessage(TELEGRAM_CHAT_ID, statsMessage);
}, 86400000); // Täglich (24 Stunden)
bot.command('server_status', async (ctx) => {
try {
const response = await axios.get(`${PLEX_URL}/status?X-Plex-Token=${PLEX_TOKEN}`);
if (response.status === 200) {
ctx.reply('✅ Plex-Server läuft einwandfrei!');
}
} catch (error) {
ctx.reply('❌ Fehler beim Abrufen des Plex-Server-Status.');
}
});
// **Stats Befehl**
bot.command('stats', async (ctx) => {
const activeSessionsCount = activeSessions.size;
const bannedUsersCount = bannedUsers.size;
const totalViolations = Array.from(userViolations.values()).reduce((acc, violations) => acc + violations, 0);
const whitelistedUsersCount = whitelist.size;
ctx.reply(`
📊 **Statistiken:**
- Aktive Sessions: ${activeSessionsCount}
- Gebannte Benutzer: ${bannedUsersCount}
- Gesamte Verstöße: ${totalViolations}
- Whitelisted Benutzer: ${whitelistedUsersCount}
`);
});
// **Whitelist Befehl zum Hinzufügen**
// Funktion zum Laden der Whitelist aus der Datei
function loadWhitelist() {
try {
const data = fs.readFileSync(whitelistFile, 'utf8');
whitelist = new Set(JSON.parse(data));
} catch (err) {
console.error('Fehler beim Laden der Whitelist:', err.message);
}
}
// Funktion zum Speichern der Whitelist in der Datei
function saveWhitelist() {
try {
fs.writeFileSync(whitelistFile, JSON.stringify(Array.from(whitelist), null, 2));
} catch (err) {
console.error('Fehler beim Speichern der Whitelist:', err.message);
}
}
// Beim Starten des Bots die Whitelist laden
loadWhitelist();
// Funktion zum Überprüfen, ob ein Benutzer auf der Whitelist ist
function isUserWhitelisted(user) {
return whitelist.has(user);
}
// **Whitelist Befehl zum Hinzufügen**
bot.command('whitelist', async (ctx) => {
const user = ctx.message.text.split(' ')[1];
if (!user) {
return ctx.reply('❌ Bitte gib den Namen des Benutzers an, den du auf die Whitelist setzen möchtest.');
}
// Überprüfen, ob der Benutzer bereits auf der Whitelist ist
if (whitelist.has(user)) {
return ctx.reply(`❌ Benutzer ${user} ist bereits auf der Whitelist.`);
}
// Benutzer zur Whitelist hinzufügen
whitelist.add(user);
saveWhitelist(); // Die Änderungen speichern
ctx.reply(`✅ Benutzer ${user} wurde erfolgreich zur Whitelist hinzugefügt.`);
});
// **Whitelist Befehl zum Entfernen**
bot.command('remove_whitelist', async (ctx) => {
const user = ctx.message.text.split(' ')[1];
if (!user) {
return ctx.reply('❌ Bitte gib den Namen des Benutzers an, den du von der Whitelist entfernen möchtest.');
}
// Überprüfen, ob der Benutzer in der Whitelist ist
if (!whitelist.has(user)) {
return ctx.reply(`❌ Benutzer ${user} ist nicht auf der Whitelist.`);
}
// Benutzer von der Whitelist entfernen
whitelist.delete(user);
saveWhitelist(); // Die Änderungen speichern
ctx.reply(`✅ Benutzer ${user} wurde erfolgreich von der Whitelist entfernt.`);
});
// Funktion zum Überprüfen, ob ein Benutzer auf der Whitelist ist
function isUserWhitelisted(user) {
return whitelist.has(user);
}
bot.command('reset_violations', async (ctx) => {
const user = ctx.message.text.split(' ')[1];
if (!user) {
return ctx.reply('❌ Bitte gib den Namen des Benutzers an, dessen Verstöße du zurücksetzen möchtest.');
}
// Verstöße zurücksetzen
userViolations.set(user, 0);
ctx.reply(`✅ Die Verstöße für Benutzer ${user} wurden zurückgesetzt.`);
});
// Bot starten
bot.launch();
// Server für Status-Check
app.get("/", (req, res) => {
res.send("Telegram-Plex-Bot läuft!");
});
let autoMode = false;
function getRecentActivities() {
const autoStatus = autoMode ? 'Aktiv' : 'Nicht Aktiv';
// Hier kannst du deine Logik einbauen, um die letzten Aktivitäten zurückzugeben
return [
`Automatik Status: ${autoStatus}`
];
}
// /auto-Befehl zum Aktivieren/Deaktivieren des Auto-Modus
bot.command('auto', async (ctx) => {
autoMode = !autoMode;
if (autoMode) {
ctx.reply('🚀 Der Auto-Modus wurde aktiviert! Alle Accountsharings werden automatisch beendet.');
} else {
ctx.reply('❌ Der Auto-Modus wurde deaktiviert.');
}
});
function getRecentActivities() {
const autoStatus = autoMode ? 'Aktiv' : 'Nicht Aktiv';
return [
`Automatik Status: ${autoStatus}`
];
}
// Funktion zur automatischen Beendigung von Accountsharing, wenn der Auto-Modus aktiviert ist
async function handleAutoMode() {
if (!autoMode) return;
for (const [user, sessions] of userSessions.entries()) {
// Überprüfen, ob der Benutzer auf der Whitelist steht
if (whitelist.has(user)) {
console.log(`${user} ist auf der Whitelist und wird nicht betroffen.`);
continue; // Überspringe den Benutzer, wenn er auf der Whitelist steht
}
if (sessions.length > 1) {
console.log(`🚫 Automatisches Beenden von Accountsharing für ${user}.`);
const stopMessage = "🚫 Accountsharing verboten. Dein Stream wurde automatisch beendet.";
await stopPlaybackWithMessage(user, stopMessage);
// Verstöße zählen und ggf. sperren
let violations = userViolations.get(user) || 0;
if (violations >= 2) {
bannedUsers.set(user, Date.now());
userViolations.delete(user);
bot.telegram.sendMessage(
TELEGRAM_CHAT_ID,
`🚫 ${user} wurde aufgrund von wiederholtem Accountsharing für 3 Stunden gesperrt.`
);
} else {
userViolations.set(user, violations + 1);
bot.telegram.sendMessage(
TELEGRAM_CHAT_ID,
`⚠️ Warnung! Accountsharing erkannt. (${violations + 1}/3 Verstöße)`
);
}
}
}
}
// Modifizierter setInterval-Aufruf für die Auto-Logik
setInterval(async () => {
await checkPlexActivity();
await handleAutoMode(); // Überprüft und beendet automatisch Accountsharing im Auto-Modus
}, 30000); // Alle 30 Sekunden
app.listen(PORT, () => console.log(`🚀 Server läuft auf Port ${PORT}`));