wunsch-bot.js aktualisiert

This commit is contained in:
M_Viper 2024-09-07 18:05:16 +00:00
parent 266da64405
commit 2e3c80305f
1 changed files with 401 additions and 396 deletions

View File

@ -1,396 +1,401 @@
require('dotenv').config(); require('dotenv').config();
const { Telegraf } = require('telegraf'); const { Telegraf } = require('telegraf');
const fs = require('fs'); const fs = require('fs');
const path = require('path'); const path = require('path');
const archiver = require('archiver'); const archiver = require('archiver');
const schedule = require('node-schedule'); const schedule = require('node-schedule');
// Initialisiere den Bot // Initialisiere den Bot
const bot = new Telegraf(process.env.TELEGRAM_TOKEN); const bot = new Telegraf(process.env.TELEGRAM_TOKEN);
// Erlaubte Gruppen-ID und Themen-ID aus der .env-Datei // Erlaubte Gruppen-ID und Themen-ID aus der .env-Datei
const allowedChatId = process.env.ALLOWED_CHAT_ID; const allowedChatId = process.env.ALLOWED_CHAT_ID;
const allowedThreadId = parseInt(process.env.ALLOWED_THREAD_ID, 10); const allowedThreadId = parseInt(process.env.ALLOWED_THREAD_ID, 10);
// Benutzerstatus-Management // Benutzerstatus-Management
const userStates = {}; const userStates = {};
// Log-Ordner und Datei-Pfade // Log-Ordner und Datei-Pfade
const logDir = path.join(__dirname, 'Log'); const logDir = path.join(__dirname, 'Log');
const errorLogFilePath = path.join(logDir, 'error.log'); const errorLogFilePath = path.join(logDir, 'error.log');
const wishLogFilePath = path.join(logDir, 'wish.log'); const wishLogFilePath = path.join(logDir, 'wish.log');
const notFoundLogFilePath = path.join(logDir, 'not_found.json'); // Pfad zur JSON-Datei für nicht gefundene Wünsche const notFoundLogFilePath = path.join(logDir, 'not_found.json'); // Pfad zur JSON-Datei für nicht gefundene Wünsche
// Stelle sicher, dass der Log-Ordner existiert // Stelle sicher, dass der Log-Ordner existiert
if (!fs.existsSync(logDir)) { if (!fs.existsSync(logDir)) {
fs.mkdirSync(logDir); fs.mkdirSync(logDir);
} }
// Funktion zum Schreiben von Fehlern in die Log-Datei // Funktion zum Schreiben von Fehlern in die Log-Datei
function logError(error) { function logError(error) {
const errorMessage = `${new Date().toISOString()} - ${error.message}\n${error.stack}\n\n`; const errorMessage = `${new Date().toISOString()} - ${error.message}\n${error.stack}\n\n`;
fs.appendFile(errorLogFilePath, errorMessage, (err) => { fs.appendFile(errorLogFilePath, errorMessage, (err) => {
if (err) { if (err) {
console.error(`Error writing to error log file: ${err.message}`); console.error(`Error writing to error log file: ${err.message}`);
} }
}); });
} }
// Funktion zum Schreiben von Wünschen in die Wunsch-Log-Datei // Funktion zum Schreiben von Wünschen in die Wunsch-Log-Datei
function logWish(wish, category, link) { function logWish(wish, category, link) {
const wishMessage = `${new Date().toISOString()} - Kategorie: ${category} - Wunsch: ${wish} - Link: ${link || 'Kein Link'}\n\n`; const wishMessage = `${new Date().toISOString()} - Kategorie: ${category} - Wunsch: ${wish} - Link: ${link || 'Kein Link'}\n\n`;
fs.appendFile(wishLogFilePath, wishMessage, (err) => { fs.appendFile(wishLogFilePath, wishMessage, (err) => {
if (err) { if (err) {
console.error(`Error writing to wish log file: ${err.message}`); console.error(`Error writing to wish log file: ${err.message}`);
} }
}); });
} }
// Funktion zum Speichern von „Nicht gefunden“-Wünschen in der JSON-Datei // Funktion zum Speichern von „Nicht gefunden“-Wünschen in der JSON-Datei
function saveNotFoundWish(wish, category) { function saveNotFoundWish(wish, category) {
let notFoundWishes = []; let notFoundWishes = [];
if (fs.existsSync(notFoundLogFilePath)) { if (fs.existsSync(notFoundLogFilePath)) {
notFoundWishes = JSON.parse(fs.readFileSync(notFoundLogFilePath, 'utf8')); notFoundWishes = JSON.parse(fs.readFileSync(notFoundLogFilePath, 'utf8'));
} }
notFoundWishes.push({ wish, category, timestamp: new Date().toISOString() }); notFoundWishes.push({ wish, category, timestamp: new Date().toISOString() });
fs.writeFileSync(notFoundLogFilePath, JSON.stringify(notFoundWishes, null, 2), 'utf8'); fs.writeFileSync(notFoundLogFilePath, JSON.stringify(notFoundWishes, null, 2), 'utf8');
} }
// Funktion zum Löschen von „Nicht gefunden“-Wünschen aus der JSON-Datei // Funktion zum Löschen von „Nicht gefunden“-Wünschen aus der JSON-Datei
function deleteNotFoundWish(index) { function deleteNotFoundWish(index) {
let notFoundWishes = []; let notFoundWishes = [];
if (fs.existsSync(notFoundLogFilePath)) { if (fs.existsSync(notFoundLogFilePath)) {
notFoundWishes = JSON.parse(fs.readFileSync(notFoundLogFilePath, 'utf8')); notFoundWishes = JSON.parse(fs.readFileSync(notFoundLogFilePath, 'utf8'));
} }
if (index >= 0 && index < notFoundWishes.length) { if (index >= 0 && index < notFoundWishes.length) {
notFoundWishes.splice(index, 1); notFoundWishes.splice(index, 1);
fs.writeFileSync(notFoundLogFilePath, JSON.stringify(notFoundWishes, null, 2), 'utf8'); fs.writeFileSync(notFoundLogFilePath, JSON.stringify(notFoundWishes, null, 2), 'utf8');
return true; return true;
} }
return false; return false;
} }
// Funktion zum Erstellen des Inline-Keyboards für die Auswahl der Wunschkategorie // Funktion zum Erstellen des Inline-Keyboards für die Auswahl der Wunschkategorie
function getCategoryKeyboard() { function getCategoryKeyboard() {
return { return {
reply_markup: JSON.stringify({ reply_markup: JSON.stringify({
inline_keyboard: [ inline_keyboard: [
[{ text: 'Film', callback_data: 'category_film' }], [{ text: 'Film', callback_data: 'category_film' }],
[{ text: 'Serie', callback_data: 'category_serie' }], [{ text: 'Serie', callback_data: 'category_serie' }],
[{ text: 'Anime', callback_data: 'category_anime' }], [{ text: 'Anime', callback_data: 'category_anime' }],
[{ text: 'Disney', callback_data: 'category_disney' }], [{ text: 'Disney', callback_data: 'category_disney' }],
[{ text: 'Medizin', callback_data: 'category_medizin' }], [{ text: 'Medizin', callback_data: 'category_medizin' }],
[{ text: 'Survival', callback_data: 'category_survival' }], [{ text: 'Survival', callback_data: 'category_survival' }],
[{ text: 'WWE', callback_data: 'category_wwe' }], [{ text: 'WWE', callback_data: 'category_wwe' }],
[{ text: 'Musik', callback_data: 'category_musik' }], [{ text: 'Musik', callback_data: 'category_musik' }],
[{ text: 'Bollywood', callback_data: 'category_bollywood' }] // Bollywood Kategorie hinzugefügt [{ text: 'Bollywood', callback_data: 'category_bollywood' }] // Bollywood Kategorie hinzugefügt
] ]
}) })
}; };
} }
// Funktion zum Erstellen der Inline-Keyboards für "Erledigt" und "Nicht gefunden" nebeneinander // Funktion zum Erstellen der Inline-Keyboards für "Erledigt" und "Nicht gefunden" nebeneinander
function getWishActionKeyboard() { function getWishActionKeyboard() {
return { return {
reply_markup: JSON.stringify({ reply_markup: JSON.stringify({
inline_keyboard: [ inline_keyboard: [
[ [
{ text: '✅ Erledigt', callback_data: 'wish_fulfilled' }, { text: '✅ Erledigt', callback_data: 'wish_fulfilled' },
{ text: '❌ Nicht gefunden', callback_data: 'wish_not_found' } { text: '❌ Nicht gefunden', callback_data: 'wish_not_found' }
] ]
] ]
}) })
}; };
} }
// Funktion zum Erstellen der Inline-Keyboards für das Löschen von „Nicht gefunden“-Wünschen // Funktion zum Erstellen der Inline-Keyboards für das Löschen von „Nicht gefunden“-Wünschen
function getDeleteNotFoundWishKeyboard() { function getDeleteNotFoundWishKeyboard() {
return { return {
reply_markup: JSON.stringify({ reply_markup: JSON.stringify({
inline_keyboard: [ inline_keyboard: [
[{ text: '🗑️ Löschen', callback_data: 'delete_not_found' }] [{ text: '🗑️ Löschen', callback_data: 'delete_not_found' }]
] ]
}) })
}; };
} }
// Funktion zum Senden des Wunsches an die Gruppe // Funktion zum Senden des Wunsches an die Gruppe
async function sendWish(wish, category, chatId, userId, link) { async function sendWish(wish, category, chatId, userId, link) {
const message = `🎬 *Ein neuer Wunsch ist eingegangen!*\n\n🔹 Kategorie: ${category}\n\n🔸 Titel: ${wish}\n\n🔗 Link: ${link || 'Kein Link'}`; const message = `🎬 *Ein neuer Wunsch ist eingegangen!*\n\n🔹 Kategorie: ${category}\n\n🔸 Titel: ${wish}\n\n🔗 Link: ${link || 'Kein Link'}`;
try { try {
// Logge den Wunsch // Logge den Wunsch
logWish(wish, category, link); logWish(wish, category, link);
// Sende die Nachricht an die Gruppe mit "Erledigt"-Button und "Nicht gefunden"-Button nebeneinander // Sende die Nachricht an die Gruppe mit "Erledigt"-Button und "Nicht gefunden"-Button nebeneinander
await bot.telegram.sendMessage(allowedChatId, message, { await bot.telegram.sendMessage(allowedChatId, message, {
message_thread_id: allowedThreadId, // Sende in das erlaubte Thema message_thread_id: allowedThreadId, // Sende in das erlaubte Thema
reply_markup: getWishActionKeyboard().reply_markup, // Füge die Buttons hinzu reply_markup: getWishActionKeyboard().reply_markup, // Füge die Buttons hinzu
}); });
} catch (error) { } catch (error) {
logError(new Error(`Error sending ${category} wish: ${error.message}`)); logError(new Error(`Error sending ${category} wish: ${error.message}`));
} }
} }
// Funktion zur Archivierung der Logs // Funktion zur Archivierung der Logs
function archiveLogs() { function archiveLogs() {
const dateStr = new Date().toISOString().split('T')[0]; const dateStr = new Date().toISOString().split('T')[0];
const zipFilePath = path.join(logDir, `logs_${dateStr}.zip`); const zipFilePath = path.join(logDir, `logs_${dateStr}.zip`);
const output = fs.createWriteStream(zipFilePath); const output = fs.createWriteStream(zipFilePath);
const archive = archiver('zip', { zlib: { level: 9 } }); const archive = archiver('zip', { zlib: { level: 9 } });
output.on('close', () => { output.on('close', () => {
console.log(`Logs archived to ${zipFilePath} (${archive.pointer()} total bytes)`); console.log(`Logs archived to ${zipFilePath} (${archive.pointer()} total bytes)`);
// Lösche die ursprünglichen Log-Dateien // Lösche die ursprünglichen Log-Dateien
if (fs.existsSync(errorLogFilePath)) fs.unlinkSync(errorLogFilePath); if (fs.existsSync(errorLogFilePath)) fs.unlinkSync(errorLogFilePath);
if (fs.existsSync(wishLogFilePath)) fs.unlinkSync(wishLogFilePath); if (fs.existsSync(wishLogFilePath)) fs.unlinkSync(wishLogFilePath);
// Neue Log-Dateien erstellen // Neue Log-Dateien erstellen
fs.writeFileSync(errorLogFilePath, ''); fs.writeFileSync(errorLogFilePath, '');
fs.writeFileSync(wishLogFilePath, ''); fs.writeFileSync(wishLogFilePath, '');
// Maximal 4 Zip-Archive behalten // Maximal 4 Zip-Archive behalten
const files = fs.readdirSync(logDir).filter(file => file.endsWith('.zip')); const files = fs.readdirSync(logDir).filter(file => file.endsWith('.zip'));
if (files.length > 4) { if (files.length > 4) {
const sortedFiles = files.sort(); const sortedFiles = files.sort();
for (let i = 0; i < sortedFiles.length - 4; i++) { for (let i = 0; i < sortedFiles.length - 4; i++) {
fs.unlinkSync(path.join(logDir, sortedFiles[i])); fs.unlinkSync(path.join(logDir, sortedFiles[i]));
} }
} }
}); });
archive.on('error', (err) => { archive.on('error', (err) => {
logError(new Error(`Error creating log archive: ${err.message}`)); logError(new Error(`Error creating log archive: ${err.message}`));
}); });
archive.pipe(output); archive.pipe(output);
archive.file(errorLogFilePath, { name: 'error.log' }); archive.file(errorLogFilePath, { name: 'error.log' });
archive.file(wishLogFilePath, { name: 'wish.log' }); archive.file(wishLogFilePath, { name: 'wish.log' });
archive.finalize(); archive.finalize();
} }
// Scheduler für die tägliche Archivierung um Mitternacht // Scheduler für die tägliche Archivierung um Mitternacht
schedule.scheduleJob('0 0 * * *', archiveLogs); schedule.scheduleJob('0 0 * * *', archiveLogs);
// Callback-Query-Handler // Callback-Query-Handler
bot.on('callback_query', async (ctx) => { bot.on('callback_query', async (ctx) => {
const data = ctx.callbackQuery.data; const data = ctx.callbackQuery.data;
const chatId = ctx.chat.id.toString(); const chatId = ctx.chat.id.toString();
const userId = ctx.callbackQuery.from.id; const userId = ctx.callbackQuery.from.id;
try { try {
if (chatId !== allowedChatId) { if (chatId !== allowedChatId) {
console.log(`Callback-Query aus nicht erlaubtem Chat: ${chatId}`); console.log(`Callback-Query aus nicht erlaubtem Chat: ${chatId}`);
return; return;
} }
if (data === 'wish_fulfilled') { if (data === 'wish_fulfilled') {
const category = userStates[chatId]?.category || 'Kanal'; const category = userStates[chatId]?.category || 'Kanal';
const message = `✨ *Wunsch wurde erfüllt!* ✨\n\n\n🎉 Der gewünschte Inhalt ist jetzt verfügbar.\n\n📺 Bitte schaue im Kanal "${category}" rein.`; const message = `✨ *Wunsch wurde erfüllt!* ✨\n\n\n🎉 Der gewünschte Inhalt ist jetzt verfügbar.\n\n📺 Bitte schaue im Kanal "${category}" rein.`;
// Sende die Nachricht mit der Information, dass der Wunsch erfüllt wurde // Sende die Nachricht mit der Information, dass der Wunsch erfüllt wurde
await bot.telegram.sendMessage(allowedChatId, message, { await bot.telegram.sendMessage(allowedChatId, message, {
message_thread_id: allowedThreadId, // In das richtige Thema posten message_thread_id: allowedThreadId, // In das richtige Thema posten
}); });
// Lösche die Nachricht // Lösche die Nachricht
await ctx.deleteMessage(ctx.callbackQuery.message.message_id); await ctx.deleteMessage(ctx.callbackQuery.message.message_id);
// Beantworte die Callback-Abfrage (damit kein Ladekreis bleibt) // Beantworte die Callback-Abfrage (damit kein Ladekreis bleibt)
await ctx.answerCbQuery(); await ctx.answerCbQuery();
} else if (data === 'wish_not_found') { } else if (data === 'wish_not_found') {
// Überprüfe, ob der Benutzer ein Admin ist // Überprüfe, ob der Benutzer ein Admin ist
const admins = await bot.telegram.getChatAdministrators(chatId); const admins = await bot.telegram.getChatAdministrators(chatId);
const isAdmin = admins.some(admin => admin.user.id === userId); const isAdmin = admins.some(admin => admin.user.id === userId);
if (isAdmin) { if (isAdmin) {
const wishTitle = userStates[chatId]?.wishTitle; const wishTitle = userStates[chatId]?.wishTitle;
const category = userStates[chatId]?.category; const category = userStates[chatId]?.category;
// Füge den Wunsch in die "Nicht gefunden"-Liste ein // Füge den Wunsch in die "Nicht gefunden"-Liste ein
if (wishTitle && category) { if (wishTitle && category) {
saveNotFoundWish(wishTitle, category); saveNotFoundWish(wishTitle, category);
} }
// Bestätige die Speicherung und entferne die Nachricht // Bestätige die Speicherung und entferne die Nachricht
await bot.telegram.sendMessage(allowedChatId, `📽️ *Sorry*,\n\n"Zum ${category} *"${wishTitle}"* \n\nwurde leider nichts gefunden. Keine Sorge, der Wunsch wurde auf unsere Liste der nicht gefundenen Titel gesetzt. Wir werden ihn prüfen und dich informieren, sobald er verfügbar ist oder gefunden wird. Vielen Dank für deine Geduld!`, { await bot.telegram.sendMessage(allowedChatId, `📽️ *Sorry*,\n\n"Zum ${category} *"${wishTitle}"* \n\nwurde leider nichts gefunden. Keine Sorge, der Wunsch wurde auf unsere Liste der nicht gefundenen Titel gesetzt. Wir werden ihn prüfen und dich informieren, sobald er verfügbar ist oder gefunden wird. Vielen Dank für deine Geduld!`, {
message_thread_id: allowedThreadId, // In das richtige Thema posten message_thread_id: allowedThreadId, // In das richtige Thema posten
}); });
await ctx.deleteMessage(ctx.callbackQuery.message.message_id); await ctx.deleteMessage(ctx.callbackQuery.message.message_id);
// Beantworte die Callback-Abfrage // Beantworte die Callback-Abfrage
await ctx.answerCbQuery(); await ctx.answerCbQuery();
} else { } else {
await ctx.answerCbQuery('Nur Admins können diese Funktion nutzen.'); await ctx.answerCbQuery('Nur Admins können diese Funktion nutzen.');
} }
} else if (data === 'delete_not_found') { } else if (data === 'delete_not_found') {
// Zeige Inline-Tastatur, um nach der Nummer des zu löschenden Eintrags zu fragen // Zeige Inline-Tastatur, um nach der Nummer des zu löschenden Eintrags zu fragen
await ctx.reply('Bitte gib die Nummer des Eintrags ein, den du löschen möchtest.', { await ctx.reply('Bitte gib die Nummer des Eintrags ein, den du löschen möchtest.', {
reply_markup: JSON.stringify({ reply_markup: JSON.stringify({
force_reply: true force_reply: true
}) })
}); });
userStates[chatId] = { ...userStates[chatId], waitingForDeleteIndex: true }; // Benutzerstatus auf „warten auf Löschnummer“ setzen userStates[chatId] = { ...userStates[chatId], waitingForDeleteIndex: true }; // Benutzerstatus auf „warten auf Löschnummer“ setzen
} else if (data.startsWith('category_')) { } else if (data.startsWith('category_')) {
// Benutzer hat die Kategorie ausgewählt // Benutzer hat die Kategorie ausgewählt
const categoryMap = { const categoryMap = {
'category_film': 'Film', 'category_film': 'Film',
'category_serie': 'Serie', 'category_serie': 'Serie',
'category_anime': 'Anime', 'category_anime': 'Anime',
'category_disney': 'Disney', 'category_disney': 'Disney',
'category_medizin': 'Medizin', 'category_medizin': 'Medizin',
'category_survival': 'Survival', 'category_survival': 'Survival',
'category_wwe': 'WWE', 'category_wwe': 'WWE',
'category_musik': 'Musik', 'category_musik': 'Musik',
'category_bollywood': 'Bollywood' // Bollywood-Kategorie hinzugefügt 'category_bollywood': 'Bollywood'
}; };
const category = categoryMap[data]; const category = categoryMap[data];
const categoryMessage = await ctx.reply(`Du hast ${category} ausgewählt. Bitte gib einen Link ein um keinen Link anzugeben einfach ein X eintragen (Optional).`, { disable_notification: true }); const categoryMessage = await ctx.reply(`Du hast die Kategorie ${category} ausgewählt. Bitte gib einen Link zum Cover oder zu Spotify ein. Falls du keinen Link angeben möchtest, trage einfach ein X ein (optional).`, { disable_notification: true });
userStates[chatId] = { userStates[chatId] = {
category, category,
waitingForLink: true, // Warten auf den Link waitingForLink: true, // Warten auf den Link
categoryMessageId: categoryMessage.message_id // Speichern der ID der Kategorie-Nachricht categoryMessageId: categoryMessage.message_id // Speichern der ID der Kategorie-Nachricht
}; };
// Entferne die Auswahl-Buttons und die /wunsch-Nachricht // Entferne die Auswahl-Buttons und die /wunsch-Nachricht
if (userStates[chatId]?.commandMessageId) { if (userStates[chatId]?.commandMessageId) {
await ctx.deleteMessage(userStates[chatId].commandMessageId).catch(e => logError(new Error(`Failed to delete command message: ${e.message}`))); await ctx.deleteMessage(userStates[chatId].commandMessageId).catch(e => logError(new Error(`Failed to delete command message: ${e.message}`)));
userStates[chatId].commandMessageId = null; // ID der Befehl-Nachricht auf null setzen userStates[chatId].commandMessageId = null; // ID der Befehl-Nachricht auf null setzen
} }
await ctx.deleteMessage(ctx.callbackQuery.message.message_id).catch(e => logError(new Error(`Failed to delete category message: ${e.message}`))); // Lösche die Kategorieauswahl-Nachricht await ctx.deleteMessage(ctx.callbackQuery.message.message_id).catch(e => logError(new Error(`Failed to delete category message: ${e.message}`))); // Lösche die Kategorieauswahl-Nachricht
} }
} catch (error) { } catch (error) {
logError(new Error(`Error handling callback query: ${error.message}`)); logError(new Error(`Error handling callback query: ${error.message}`));
} }
// Markiere die Callback-Abfrage als beantwortet // Markiere die Callback-Abfrage als beantwortet
ctx.answerCbQuery().catch(error => { ctx.answerCbQuery().catch(error => {
logError(new Error(`Error answering callback query: ${error.message}`)); logError(new Error(`Error answering callback query: ${error.message}`));
}); });
}); });
// Nachrichten-Handler // Nachrichten-Handler
bot.on('text', async (ctx) => { bot.on('text', async (ctx) => {
const chatId = ctx.chat.id.toString(); const chatId = ctx.chat.id.toString();
const userId = ctx.message.from.id; const userId = ctx.message.from.id;
const text = ctx.message.text; const text = ctx.message.text;
const threadId = ctx.message?.message_thread_id; // Thema-ID (falls vorhanden) const threadId = ctx.message?.message_thread_id; // Thema-ID (falls vorhanden)
console.log(`Received message in chat ID ${chatId} and thread ID ${threadId}: ${text}`); // Logging zur Diagnose console.log(`Received message in chat ID ${chatId} and thread ID ${threadId}: ${text}`); // Logging zur Diagnose
if (chatId !== allowedChatId || threadId !== allowedThreadId) { if (chatId !== allowedChatId || threadId !== allowedThreadId) {
console.log(`Ignoring message in chat ID ${chatId} and thread ID ${threadId} as it's not allowed.`); console.log(`Ignoring message in chat ID ${chatId} and thread ID ${threadId} as it's not allowed.`);
return; if (text.startsWith('/wunsch')) {
} // Nachricht zurückweisen, wenn der Befehl in einem nicht erlaubten Kanal verwendet wird
await ctx.reply('❌ Dieser Befehl ist in diesem Kanal nicht erlaubt. Bitte benutze den Befehl in den Serien- und Filmwünsche Kanal.', { disable_notification: true });
// Überprüfe, ob der Benutzer in der Eingabestimmung ist }
if (userStates[chatId]) { return;
if (userStates[chatId].waitingForLink) { }
// Verarbeite den Link des Wunsches
const link = text.trim(); // Link erhalten // Überprüfe, ob der Benutzer in der Eingabestimmung ist
userStates[chatId].wishLink = link; // Speichern des Links if (userStates[chatId]) {
if (userStates[chatId].waitingForLink) {
// Frage nach dem Titel des Wunsches // Verarbeite den Link des Wunsches
await ctx.reply(`Bitte gib den Titel des ${userStates[chatId].category} ein.`, { disable_notification: true }); const link = text.trim(); // Link erhalten
userStates[chatId].wishLink = link; // Speichern des Links
userStates[chatId].waitingForLink = false; // Status zurücksetzen
userStates[chatId].waitingForWish = true; // Nun auf den Wunsch warten // Frage nach dem Titel des Wunsches
return; // Beende die Verarbeitung, da der Benutzer jetzt nach dem Titel gefragt wird await ctx.reply(`Bitte gib den Titel des ${userStates[chatId].category} ein.`, { disable_notification: true });
}
userStates[chatId].waitingForLink = false; // Status zurücksetzen
if (userStates[chatId].waitingForWish) { userStates[chatId].waitingForWish = true; // Nun auf den Wunsch warten
// Verarbeite den Titel des Wunsches return; // Beende die Verarbeitung, da der Benutzer jetzt nach dem Titel gefragt wird
const wish = text.trim(); // Titel erhalten }
if (wish) {
const category = userStates[chatId].category; if (userStates[chatId].waitingForWish) {
const link = userStates[chatId].wishLink; // Verarbeite den Titel des Wunsches
const categoryMessageId = userStates[chatId].categoryMessageId; const wish = text.trim(); // Titel erhalten
const titleMessageId = ctx.message.message_id; // ID der Titel-Nachricht erhalten if (wish) {
const commandMessageId = userStates[chatId].commandMessageId; // ID der Befehl-Nachricht erhalten const category = userStates[chatId].category;
const wishCommandMessageId = userStates[chatId].wishCommandMessageId; // ID der /wunsch-Nachricht erhalten const link = userStates[chatId].wishLink;
const categoryMessageId = userStates[chatId].categoryMessageId;
try { const titleMessageId = ctx.message.message_id; // ID der Titel-Nachricht erhalten
userStates[chatId].wishTitle = wish; // Speichern des Wunsch-Titels für spätere Verwendung const commandMessageId = userStates[chatId].commandMessageId; // ID der Befehl-Nachricht erhalten
await sendWish(wish, category, chatId, userId, link); const wishCommandMessageId = userStates[chatId].wishCommandMessageId; // ID der /wunsch-Nachricht erhalten
// Lösche die Nachrichten, die beim Verarbeiten des Wunsches gesendet wurden try {
if (categoryMessageId) await ctx.deleteMessage(categoryMessageId).catch(e => logError(new Error(`Failed to delete category message: ${e.message}`))); userStates[chatId].wishTitle = wish; // Speichern des Wunsch-Titels für spätere Verwendung
if (titleMessageId) await ctx.deleteMessage(titleMessageId).catch(e => logError(new Error(`Failed to delete title message: ${e.message}`))); await sendWish(wish, category, chatId, userId, link);
if (commandMessageId) await ctx.deleteMessage(commandMessageId).catch(e => logError(new Error(`Failed to delete command message: ${e.message}`)));
if (wishCommandMessageId) await ctx.deleteMessage(wishCommandMessageId).catch(e => logError(new Error(`Failed to delete /wunsch message: ${e.message}`))); // Lösche die Nachrichten, die beim Verarbeiten des Wunsches gesendet wurden
if (categoryMessageId) await ctx.deleteMessage(categoryMessageId).catch(e => logError(new Error(`Failed to delete category message: ${e.message}`)));
userStates[chatId].waitingForWish = false; // Benutzerstatus zurücksetzen if (titleMessageId) await ctx.deleteMessage(titleMessageId).catch(e => logError(new Error(`Failed to delete title message: ${e.message}`)));
} catch (error) { if (commandMessageId) await ctx.deleteMessage(commandMessageId).catch(e => logError(new Error(`Failed to delete command message: ${e.message}`)));
logError(new Error(`Error processing wish: ${error.message}`)); if (wishCommandMessageId) await ctx.deleteMessage(wishCommandMessageId).catch(e => logError(new Error(`Failed to delete /wunsch message: ${e.message}`)));
}
} else { userStates[chatId].waitingForWish = false; // Benutzerstatus zurücksetzen
await ctx.reply(`Bitte gib den Titel des ${userStates[chatId].category} ein.`, { disable_notification: true }); } catch (error) {
} logError(new Error(`Error processing wish: ${error.message}`));
return; // Beende die Verarbeitung, wenn der Benutzer in der Eingabestimmung ist }
} } else {
await ctx.reply(`Bitte gib den Titel des ${userStates[chatId].category} ein.`, { disable_notification: true });
if (userStates[chatId].waitingForDeleteIndex) { }
// Verarbeite die Löschanfrage return; // Beende die Verarbeitung, wenn der Benutzer in der Eingabestimmung ist
const index = parseInt(text.trim(), 10) - 1; // Index aus der Nachricht extrahieren }
if (deleteNotFoundWish(index)) {
await ctx.reply('Der Eintrag wurde erfolgreich gelöscht.'); if (userStates[chatId].waitingForDeleteIndex) {
} else { // Verarbeite die Löschanfrage
await ctx.reply('Ungültige Nummer. Bitte versuche es erneut.'); const index = parseInt(text.trim(), 10) - 1; // Index aus der Nachricht extrahieren
} if (deleteNotFoundWish(index)) {
userStates[chatId].waitingForDeleteIndex = false; // Benutzerstatus zurücksetzen await ctx.reply('Der Eintrag wurde erfolgreich gelöscht.');
return; } else {
} await ctx.reply('Ungültige Nummer. Bitte versuche es erneut.');
} }
userStates[chatId].waitingForDeleteIndex = false; // Benutzerstatus zurücksetzen
if (text.startsWith('/wunsch')) { return;
// Benutzer zur Auswahl der Kategorie auffordern }
const commandMessage = await ctx.reply('Möchtest du etwas wünschen? Wähle bitte eine Kategorie:', { ...getCategoryKeyboard(), disable_notification: true }); }
userStates[chatId] = {
waitingForCategory: true, if (text.startsWith('/wunsch')) {
commandMessageId: commandMessage.message_id, // Speichern der ID der Befehl-Nachricht // Benutzer zur Auswahl der Kategorie auffordern
wishCommandMessageId: ctx.message.message_id // Speichern der ID der /wunsch-Nachricht const commandMessage = await ctx.reply('Möchtest du etwas wünschen? Wähle bitte eine Kategorie:', { ...getCategoryKeyboard(), disable_notification: true });
}; // Setze den Status auf "wartend auf Kategorie" userStates[chatId] = {
} else if (text.startsWith('/notfound')) { waitingForCategory: true,
// Überprüfe, ob der Benutzer ein Admin ist commandMessageId: commandMessage.message_id, // Speichern der ID der Befehl-Nachricht
const admins = await bot.telegram.getChatAdministrators(chatId); wishCommandMessageId: ctx.message.message_id // Speichern der ID der /wunsch-Nachricht
const isAdmin = admins.some(admin => admin.user.id === userId); }; // Setze den Status auf "wartend auf Kategorie"
} else if (text.startsWith('/notfound')) {
if (isAdmin) { // Überprüfe, ob der Benutzer ein Admin ist
if (fs.existsSync(notFoundLogFilePath)) { const admins = await bot.telegram.getChatAdministrators(chatId);
const notFoundWishes = JSON.parse(fs.readFileSync(notFoundLogFilePath, 'utf8')); const isAdmin = admins.some(admin => admin.user.id === userId);
let replyMessage = '🔍 Liste der nicht gefundenen Wünsche:\n\n';
if (isAdmin) {
if (notFoundWishes.length === 0) { if (fs.existsSync(notFoundLogFilePath)) {
replyMessage += 'Keine nicht gefundenen Wünsche.'; const notFoundWishes = JSON.parse(fs.readFileSync(notFoundLogFilePath, 'utf8'));
} else { let replyMessage = '🔍 Liste der nicht gefundenen Wünsche:\n\n';
notFoundWishes.forEach((entry, index) => {
replyMessage += `${index + 1}. Kategorie: ${entry.category}\n Wunsch: ${entry.wish}\n\n\n`; if (notFoundWishes.length === 0) {
}); replyMessage += 'Keine nicht gefundenen Wünsche.';
replyMessage += '\n🗑 [Löschen]'; } else {
} notFoundWishes.forEach((entry, index) => {
replyMessage += `${index + 1}. Kategorie: ${entry.category}\n Wunsch: ${entry.wish}\n\n\n`;
// Sende die Liste direkt an den Admin });
await ctx.reply(replyMessage, { disable_notification: true, ...getDeleteNotFoundWishKeyboard() }); replyMessage += '\n🗑 [Löschen]';
}
// Lösche den /notfound Befehl
await ctx.deleteMessage(ctx.message.message_id).catch(e => logError(new Error(`Failed to delete /notfound command message: ${e.message}`))); // Sende die Liste direkt an den Admin
} else { await ctx.reply(replyMessage, { disable_notification: true, ...getDeleteNotFoundWishKeyboard() });
await ctx.reply('Noch keine nicht gefundenen Wünsche aufgezeichnet.', { disable_notification: true });
} // Lösche den /notfound Befehl
} else { await ctx.deleteMessage(ctx.message.message_id).catch(e => logError(new Error(`Failed to delete /notfound command message: ${e.message}`)));
await ctx.reply('❌ Du bist nicht berechtigt, diese Funktion zu nutzen. ❌', { disable_notification: true }); } else {
} await ctx.reply('Noch keine nicht gefundenen Wünsche aufgezeichnet.', { disable_notification: true });
} }
}); } else {
await ctx.reply('❌ Du bist nicht berechtigt, diese Funktion zu nutzen. ❌', { disable_notification: true });
bot.launch(); }
}
console.log('Bot is running...'); });
bot.launch();
console.log('Bot is running...');