Dateien nach "/" hochladen
This commit is contained in:
4
.env
Normal file
4
.env
Normal 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
599
bot.js
Normal 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}`));
|
||||
Reference in New Issue
Block a user