plex-bot.js aktualisiert

plex-bot.js

@@ -17,6 +17,7 @@ const { scheduleJob } = require('node-schedule');
 const { format } = require('date-fns');
 const archiver = require('archiver');
 
+
 const today = format(new Date(), 'yyyy-MM-dd');
 console.log(today); // Sollte das aktuelle Datum im Format yyyy-MM-dd ausgeben
 
@@ -509,150 +510,28 @@ function updateEnvPassword(newPassword) {
   passwordChangeRequired = false;  // Sperre aufheben, Login wieder möglich
 }
 
-const usersNightMode = {}; // Temporärer Speicher für Nachtmodus
 
-// Funktion zum Laden der Benutzerdaten aus der user.yml
-function loadUserData() {
-    if (!fs.existsSync(USER_YML_PATH)) {
-        fs.writeFileSync(USER_YML_PATH, yaml.stringify({}));
-    }
-    return yaml.load(USER_YML_PATH);
-}
 
-// Funktion zum Speichern der Benutzerdaten in die user.yml
-function saveUserData(userData) {
-    fs.writeFileSync(USER_YML_PATH, yaml.stringify(userData, 4));
-}
 
-// /night Befehl
-bot.onText(/\/night/, (msg) => {
-    const chatId = msg.chat.id;
-    const userData = loadUserData(); // Lade die Benutzerdaten
-    const userId = chatId.toString();
 
-    bot.sendMessage(chatId, 'Bitte geben Sie die Startzeit des Nachtmodus im Format HH:mm ein (z.B. 22:00):');
 
-    bot.once('message', (msg) => {
-        const startTime = msg.text;
-        if (!/^\d{2}:\d{2}$/.test(startTime)) {
-            return bot.sendMessage(chatId, 'Ungültiges Zeitformat. Bitte geben Sie die Zeit im Format HH:mm ein.');
-        }
 
-        bot.sendMessage(chatId, 'Bitte geben Sie die Endzeit des Nachtmodus im Format HH:mm ein (z.B. 06:00):');
 
-        bot.once('message', (msg) => {
-            const endTime = msg.text;
-            if (!/^\d{2}:\d{2}$/.test(endTime)) {
-                return bot.sendMessage(chatId, 'Ungültiges Zeitformat. Bitte geben Sie die Zeit im Format HH:mm ein.');
-            }
 
-            // Speichere die Nachtmodus-Daten ohne die Benachrichtigungen sofort zu deaktivieren
-            userData[userId] = userData[userId] || {};
-            userData[userId].nightMode = { startTime, endTime };
-            saveUserData(userData); // Speichere die Daten in die yml-Datei
 
-            bot.sendMessage(chatId, `🌓 Nachtmodus geplant von ${startTime} bis ${endTime}. Benachrichtigungen werden deaktiviert, wenn der Nachtmodus beginnt.`);
-        });
-    });
-});
 
-// Funktion zur Überprüfung, ob der Benutzer im Nachtmodus ist
-function isUserInNightMode(chatId) {
-    const userData = loadUserData();
-    const userId = chatId.toString();
-    const userNightMode = userData[userId] && userData[userId].nightMode;
 
-    if (!userNightMode) return false;
 
-    const now = moment();
-    const start = moment(userNightMode.startTime, 'HH:mm');
-    const end = moment(userNightMode.endTime, 'HH:mm');
 
-    if (end.isBefore(start)) {
-        return now.isAfter(start) || now.isBefore(end); // Nachtmodus über Mitternacht
-    } else {
-        return now.isBetween(start, end); // Normaler Nachtmodus
-    }
-}
 
-// Überprüft und stellt den Nachtmodus nach Ablauf wieder her
-function resetNotificationsAfterNightMode() {
-    const userData = loadUserData();
 
-    for (const userId in userData) {
-        if (isUserInNightMode(userId)) continue;
 
-        // Setze die Benachrichtigungseinstellungen auf den ursprünglichen Wert zurück
-        if (userData[userId].originalNotifications !== undefined) {
-            userData[userId].notifications = userData[userId].originalNotifications;
-            delete userData[userId].originalNotifications; // Lösche die temporäre Speicherung
-            saveUserData(userData);
-        }
-    }
-}
 
-// Funktion zur automatischen Aktivierung des Nachtmodus
-function activateNightMode() {
-    const userData = loadUserData();
 
-    for (const userId in userData) {
-        const userNightMode = userData[userId] && userData[userId].nightMode;
-        if (!userNightMode) continue;
 
-        const now = moment();
-        const start = moment(userNightMode.startTime, 'HH:mm');
-        const end = moment(userNightMode.endTime, 'HH:mm');
 
-        // Wenn die Startzeit erreicht ist und die Benachrichtigungen noch nicht deaktiviert wurden, deaktiviere sie
-        if (now.isSameOrAfter(start) && userData[userId].notifications !== false) {
-            userData[userId].originalNotifications = userData[userId].notifications;
-            userData[userId].notifications = false;
-            saveUserData(userData);
-            bot.sendMessage(userId, `🌓 Der Nachtmodus hat begonnen. Deine Benachrichtigungen wurden auf Stumm geschaltet.`);
-            console.log(`Nachtmodus für Benutzer ${userId} aktiviert.`);
-        }
 
-        // Wenn die Endzeit erreicht ist und die Benachrichtigungen deaktiviert wurden, aktiviere sie wieder
-        if (now.isSameOrAfter(end) && userData[userId].notifications === false) {
-            userData[userId].notifications = userData[userId].originalNotifications;
-            delete userData[userId].originalNotifications; // Lösche die temporäre Speicherung
-            saveUserData(userData);
-            bot.sendMessage(userId, `🌓 Der Nachtmodus endet, die Benachrichtigungen sind jetzt wieder aktiv.`);
-            console.log(`Nachtmodus für Benutzer ${userId} deaktiviert.`);
-        }
-    }
-}
 
-// Automatische Nachtmodus-Aktivierung und Zurücksetzung überwachen
-setInterval(() => {
-    activateNightMode(); // Nachtmodus aktivieren, wenn es Zeit ist
-    resetNotificationsAfterNightMode(); // Benachrichtigungen nach dem Nachtmodus zurücksetzen
-}, 60 * 1000); // Überprüfung alle 60 Sekunden
-
-// /night_off Befehl
-bot.onText(/\/n_off/, (msg) => {
-  const chatId = msg.chat.id;
-  const userData = loadUserData(); // Lade die Benutzerdaten
-  const userId = chatId.toString();
-
-  if (userData[userId] && userData[userId].nightMode) {
-      // Setze die Benachrichtigungseinstellungen auf den ursprünglichen Wert zurück
-      if (userData[userId].originalNotifications !== undefined) {
-          userData[userId].notifications = userData[userId].originalNotifications;
-          delete userData[userId].originalNotifications; // Lösche die temporäre Speicherung
-      }
-
-      // Entferne die Nachtmodus-Daten
-      delete userData[userId].nightMode;
-
-      // Speichere die Änderungen in der user.yml-Datei
-      saveUserData(userData);
-
-      bot.sendMessage(chatId, '🌓 Der Nachtmodus wurde deaktiviert. Benachrichtigungen sind wieder aktiviert.');
-  } else {
-      bot.sendMessage(chatId, 'Es ist kein Nachtmodus aktiv.');
-  }
-});
 
 
 
@@ -1088,6 +967,23 @@ if (query.data.startsWith('change_email')) {
 }
 });
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // Lade Abonnenten beim Start
 loadSubscribers();
 
@@ -1139,7 +1035,6 @@ bot.onText(/\/profil/, (msg) => {
       }
       const role = roles.length > 0 ? roles.join(', ') : 'Benutzer';
 
-      // Schritt 2: Newsletter-Status aus subscribers.json lesen
       fs.readFile(subscribersFilePath, 'utf8', (err, subsData) => {
         if (err) {
             console.error(`Fehler beim Lesen der Datei ${subscribersFilePath}: ${err}`);
@@ -1148,7 +1043,17 @@ bot.onText(/\/profil/, (msg) => {
             return;
         }
     
-          const subscribers = JSON.parse(subsData);
+        let subscribers;
+        try {
+            subscribers = JSON.parse(subsData); // JSON sicher parsen
+        } catch (parseErr) {
+            console.error('Fehler beim Parsen der subscribers.json:', parseErr);
+            bot.sendMessage(chatId, 'Fehler beim Verarbeiten der Abonnentendaten.')
+                .catch(error => console.error(`Fehler bei der Nachricht: ${error.message}`));
+            return;
+        }
+    
+        // Status prüfen, ob der Benutzer abonniert ist
         const isSubscribed = subscribers.some(subscriber => subscriber.chatId === chatId);
         const newsletterStatus = isSubscribed ? 'Ja' : 'Nein';
 
@@ -1158,8 +1063,12 @@ bot.onText(/\/profil/, (msg) => {
             let notificationStatus = user.notifications ? 'Ja' : 'Nein';
 
             if (!err) {
+                try {
                     const userWishes = JSON.parse(wishesData);
                     wishesCount = userWishes.length;
+                } catch (parseErr) {
+                    console.error('Fehler beim Parsen der wishes-Datei:', parseErr);
+                }
             }
 
             // Schritt 4: Anzahl der Feedbacks zählen
@@ -1190,8 +1099,6 @@ bot.onText(/\/profil/, (msg) => {
 🔔 *Benachrichtigung:* ${notificationStatus}\n
 `.trim(); // Whitespace entfernen
 
-//🎞️ *Lieblingsgenre:* ${favoriteGenre}\n
-
                         // Sende Profilinformationen und zeige Button an
                         bot.sendMessage(chatId, profileMessage, {
                             parse_mode: 'MarkdownV2',
@@ -1232,6 +1139,7 @@ bot.onText(/\/profil/, (msg) => {
   });
 });
 
+
 // Callback query handler for profile editing
 bot.on('callback_query', (callbackQuery) => {
   const action = callbackQuery.data;
@@ -1243,7 +1151,7 @@ bot.on('callback_query', (callbackQuery) => {
         reply_markup: {
             inline_keyboard: [
                 [
-                    //{ text: 'Lieblingsgenre setzen', callback_data: 'set_favorite_genre' },
+                    { text: 'Lieblingsgenre setzen', callback_data: 'set_favorite_genre' },
                     { text: 'Profil zurücksetzen', callback_data: 'reset_profile' }
                 ],
                 [
@@ -1413,11 +1321,21 @@ bot.on('callback_query', (callbackQuery) => {
                         return;
                     }
 
-                    const wOffen = load(wOffenData);
+                    let wOffen;
-                    delete wOffen[chatId]; // Entferne den Benutzer aus w_offen.json
+                    try {
+                        wOffen = JSON.parse(wOffenData); // Sicheres Parsen der JSON-Daten
+                    } catch (parseErr) {
+                        console.error(`Fehler beim Parsen der w_offen.json: ${parseErr}`);
+                        bot.sendMessage(chatId, 'Fehler beim Löschen des Profils.')
+                            .catch(error => console.error(`Fehler bei der Nachricht: ${error.message}`));
+                        return;
+                    }
 
-                    // Schreibe die aktualisierten Einträge zurück in die w_offen.json
+                    // Entferne alle Wünsche des Benutzers
-                    fs.writeFile(wOffenFilePath, dump(wOffen), 'utf8', (err) => {
+                    wOffen = wOffen.filter(wish => wish.userId !== chatId);
+
+                    // Schreibe die aktualisierten Wünsche zurück in die w_offen.json
+                    fs.writeFile(wOffenFilePath, JSON.stringify(wOffen, null, 2), 'utf8', (err) => {
                         if (err) {
                             console.error(`Fehler beim Schreiben in die Datei ${wOffenFilePath}: ${err}`);
                             bot.sendMessage(chatId, 'Fehler beim Löschen des Profils.')
@@ -1497,16 +1415,26 @@ function formatDate(dateString) {
 }
 
 // Funktion zum Bestimmen des Benutzerlevels
-function getUserLevel(commandCount, wishCount) {
+function getUserLevel(commandCount) {
   let level = 'Neuling';
 
   // Kriterien für die Vergabe des Benutzerlevels
-  if (commandCount > 50) {
+  if (commandCount >= 6000) {
-    level = 'VIP Benutzer';
+    level = 'Legendärer Benutzer';
-  } else if (commandCount > 20) {
+  } else if (commandCount >= 3000) {
+    level = 'Meister Benutzer';
+  } else if (commandCount >= 1600) {
+    level = 'Fortgeschrittener Benutzer';
+  } else if (commandCount >= 800) {
     level = 'Erfahrener Benutzer';
-  } else if (commandCount > 5 || wishCount > 1) {
+  } else if (commandCount >= 400) {
+    level = 'VIP Benutzer';
+  } else if (commandCount >= 200) {
     level = 'Aktiver Benutzer';
+  } else if (commandCount >= 100) {
+    level = 'Gelegentlicher Benutzer'; 
+  } else if (commandCount >= 30) {
+    level = 'Neuling';
   }
 
   return level;
@@ -1568,6 +1496,24 @@ bot.on('message', (msg) => {
   });
 });
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // Befehl zum Sichern der Dateien
 bot.onText(/\/backup/, (msg) => {
   const chatId = msg.chat.id;
@@ -3294,6 +3240,304 @@ async function fetchPlexData(url) {
   }
 }
 
+const usersNightMode = {}; // Temporärer Speicher für Nachtmodus
+
+// Funktion zum Laden der Benutzerdaten aus der user.yml
+function loadUserData() {
+    if (!fs.existsSync(USER_YML_PATH)) {
+        fs.writeFileSync(USER_YML_PATH, yaml.stringify({}));
+    }
+    return yaml.load(USER_YML_PATH);
+}
+
+// Funktion zum Speichern der Benutzerdaten in die user.yml
+function saveUserData(userData) {
+    fs.writeFileSync(USER_YML_PATH, yaml.stringify(userData, 4));
+}
+
+// Funktion zum Anheften der Nachtmodus-Nachricht
+function pinNightModeMessage(chatId, messageId) {
+    bot.pinChatMessage(chatId, messageId).catch(err => console.error('Fehler beim Anheften der Nachricht:', err));
+}
+
+// Funktion zum Entfernen der angehefteten Nachricht
+function unpinNightModeMessage(chatId) {
+    bot.unpinChatMessage(chatId).catch(err => console.error('Fehler beim Entfernen der angehefteten Nachricht:', err));
+}
+
+// /night Befehl
+bot.onText(/\/night/, (msg) => {
+  const chatId = msg.chat.id;
+  const userData = loadUserData(); // Lade die Benutzerdaten
+  const userId = chatId.toString();
+
+  // Standard-Buttons
+  const buttons = [];
+
+  // Überprüfen, ob der Benutzer bereits Nachtmodi hat
+  if (!userData[userId] || !userData[userId].nightModes || userData[userId].nightModes.length === 0) {
+      buttons.push([{ text: '🌙 Nachtmodus eingeben', callback_data: 'input_night_mode' }]);
+  } else {
+      buttons.push(
+          [
+              { text: '🛠️ Nachtmodus bearbeiten', callback_data: 'edit_night_mode' },
+              { text: '➕ Weiteren Nachtmodus eingeben', callback_data: 'add_night_mode' }
+          ],
+          [{ text: '🗑️ Nachtmodus löschen', callback_data: 'delete_night_mode' }]
+      );
+  }
+
+  // Zeige die Inline-Buttons an
+  bot.sendMessage(chatId, 'Wählen Sie eine Option:', {
+      reply_markup: {
+          inline_keyboard: buttons,
+      },
+  });
+});
+
+// Callback-Query-Handler für die Inline-Buttons
+bot.on('callback_query', (query) => {
+    const chatId = query.message.chat.id;
+    const userId = chatId.toString();
+    const userData = loadUserData(); // Lade die Benutzerdaten
+
+    if (query.data === 'input_night_mode') {
+        // Eingabe eines neuen Nachtmodus
+        bot.sendMessage(chatId, 'Bitte geben Sie die Startzeit des Nachtmodus im Format HH:mm ein (z.B. 22:00):');
+
+        bot.once('message', (msg) => {
+            const startTime = msg.text;
+
+            // Sicherstellen, dass msg.text existiert und gültig ist
+            if (!startTime || !/^\d{2}:\d{2}$/.test(startTime)) {
+                return bot.sendMessage(chatId, 'Ungültiges Zeitformat. Bitte geben Sie die Zeit im Format HH:mm ein.');
+            }
+
+            bot.sendMessage(chatId, 'Bitte geben Sie die Endzeit des Nachtmodus im Format HH:mm ein (z.B. 06:00):');
+
+            bot.once('message', (msg) => {
+                const endTime = msg.text;
+
+                // Sicherstellen, dass msg.text existiert und gültig ist
+                if (!endTime || !/^\d{2}:\d{2}$/.test(endTime)) {
+                    return bot.sendMessage(chatId, 'Ungültiges Zeitformat. Bitte geben Sie die Zeit im Format HH:mm ein.');
+                }
+
+                // Speichere die Nachtmodus-Daten
+                userData[userId] = userData[userId] || {};
+                userData[userId].nightModes = userData[userId].nightModes || [];
+                userData[userId].nightModes.push({ startTime, endTime });
+                saveUserData(userData); // Speichere die Daten in die yml-Datei
+
+                bot.sendMessage(chatId, `🌓 Nachtmodus geplant von ${startTime} bis ${endTime}.`);
+            });
+        });
+    } else if (query.data === 'edit_night_mode') {
+        // Bearbeiten eines bestehenden Nachtmodus
+        if (userData[userId] && userData[userId].nightModes && userData[userId].nightModes.length > 0) {
+            const nightModes = userData[userId].nightModes;
+
+            let nightModesText = 'Aktuelle Nachtmodi:\n';
+            nightModes.forEach((mode, index) => {
+                nightModesText += `${index + 1}: ${mode.startTime} bis ${mode.endTime}\n`;
+            });
+
+            nightModesText += 'Geben Sie die Nummer des Nachtmodus ein, den Sie bearbeiten möchten:';
+            bot.sendMessage(chatId, nightModesText);
+
+            bot.once('message', (msg) => {
+                const modeIndex = parseInt(msg.text) - 1;
+
+                if (isNaN(modeIndex) || modeIndex < 0 || modeIndex >= nightModes.length) {
+                    return bot.sendMessage(chatId, 'Ungültige Auswahl.');
+                }
+
+                bot.sendMessage(chatId, 'Bitte geben Sie die neue Startzeit im Format HH:mm ein (z.B. 22:00):');
+
+                bot.once('message', (msg) => {
+                    const newStartTime = msg.text;
+
+                    // Sicherstellen, dass msg.text existiert und gültig ist
+                    if (!newStartTime || !/^\d{2}:\d{2}$/.test(newStartTime)) {
+                        return bot.sendMessage(chatId, 'Ungültiges Zeitformat. Bitte geben Sie die Zeit im Format HH:mm ein.');
+                    }
+
+                    bot.sendMessage(chatId, 'Bitte geben Sie die neue Endzeit im Format HH:mm ein (z.B. 06:00):');
+
+                    bot.once('message', (msg) => {
+                        const newEndTime = msg.text;
+
+                        // Sicherstellen, dass msg.text existiert und gültig ist
+                        if (!newEndTime || !/^\d{2}:\d{2}$/.test(newEndTime)) {
+                            return bot.sendMessage(chatId, 'Ungültiges Zeitformat. Bitte geben Sie die Zeit im Format HH:mm ein.');
+                        }
+
+                        // Aktualisiere den Nachtmodus
+                        userData[userId].nightModes[modeIndex] = { startTime: newStartTime, endTime: newEndTime };
+                        saveUserData(userData); // Speichere die Änderungen
+
+                        bot.sendMessage(chatId, `🌓 Nachtmodus aktualisiert auf ${newStartTime} bis ${newEndTime}.`);
+                    });
+                });
+            });
+        } else {
+            bot.sendMessage(chatId, 'Es sind keine Nachtmodi zum Bearbeiten vorhanden.');
+        }
+    } else if (query.data === 'add_night_mode') {
+        // Eingabe eines weiteren Nachtmodus
+        bot.sendMessage(chatId, 'Bitte geben Sie die Startzeit des Nachtmodus im Format HH:mm ein (z.B. 22:00):');
+
+        bot.once('message', (msg) => {
+            const startTime = msg.text;
+
+            // Sicherstellen, dass msg.text existiert und gültig ist
+            if (!startTime || !/^\d{2}:\d{2}$/.test(startTime)) {
+                return bot.sendMessage(chatId, 'Ungültiges Zeitformat. Bitte geben Sie die Zeit im Format HH:mm ein.');
+            }
+
+            bot.sendMessage(chatId, 'Bitte geben Sie die Endzeit des Nachtmodus im Format HH:mm ein (z.B. 06:00):');
+
+            bot.once('message', (msg) => {
+                const endTime = msg.text;
+
+                // Sicherstellen, dass msg.text existiert und gültig ist
+                if (!endTime || !/^\d{2}:\d{2}$/.test(endTime)) {
+                    return bot.sendMessage(chatId, 'Ungültiges Zeitformat. Bitte geben Sie die Zeit im Format HH:mm ein.');
+                }
+
+                // Speichere den neuen Nachtmodus
+                userData[userId].nightModes.push({ startTime, endTime });
+                saveUserData(userData); // Speichere die Daten in die yml-Datei
+
+                bot.sendMessage(chatId, `🌓 Weiterer Nachtmodus geplant von ${startTime} bis ${endTime}.`);
+            });
+        });
+    } else if (query.data === 'delete_night_mode') {
+      // Zeige Liste der Nachtmodi zum Löschen
+      if (userData[userId] && userData[userId].nightModes && userData[userId].nightModes.length > 0) {
+          const nightModes = userData[userId].nightModes;
+  
+          let nightModesText = '🔄 **Bitte wählen Sie einen Nachtmodus zum Löschen:**\n\n';
+          nightModes.forEach((mode, index) => {
+              nightModesText += `🕒 **${index + 1}:** ${mode.startTime} bis ${mode.endTime}\n`;
+          });
+  
+          nightModesText += '\n🗑️ *Geben Sie die Nummer des Nachtmodus ein, den Sie löschen möchten:*';
+          bot.sendMessage(chatId, nightModesText);
+  
+          bot.once('message', (msg) => {
+              const modeIndex = parseInt(msg.text) - 1;
+  
+              if (isNaN(modeIndex) || modeIndex < 0 || modeIndex >= nightModes.length) {
+                  return bot.sendMessage(chatId, 'Ungültige Auswahl.');
+              }
+  
+              // Lösche den ausgewählten Nachtmodus
+              userData[userId].nightModes.splice(modeIndex, 1); // Lösche den Nachtmodus an der gegebenen Indexposition
+              saveUserData(userData); // Speichere die Änderungen
+              bot.sendMessage(chatId, '🗑️ Der ausgewählte Nachtmodus wurde gelöscht.');
+          });
+      } else {
+          bot.sendMessage(chatId, 'Es gibt keinen Nachtmodus, der gelöscht werden kann.');
+      }
+  }
+});
+
+// Funktion zur Überprüfung, ob der Benutzer im Nachtmodus ist
+function isUserInNightMode(chatId) {
+    const userData = loadUserData();
+    const userId = chatId.toString();
+    const userNightModes = userData[userId] && userData[userId].nightModes;
+
+    if (!userNightModes || userNightModes.length === 0) return false;
+
+    const now = moment();
+
+    return userNightModes.some(userNightMode => {
+        const start = moment(userNightMode.startTime, 'HH:mm');
+        const end = moment(userNightMode.endTime, 'HH:mm');
+
+        if (end.isBefore(start)) {
+            return now.isAfter(start) || now.isBefore(end); // Nachtmodus über Mitternacht
+        } else {
+            return now.isBetween(start, end); // Normaler Nachtmodus
+        }
+    });
+}
+
+// Funktion zur automatischen Aktivierung des Nachtmodus
+function activateNightMode() {
+    const userData = loadUserData();
+
+    for (const userId in userData) {
+        const userNightModes = userData[userId] && userData[userId].nightModes;
+        if (!userNightModes) continue;
+
+        const now = moment();
+
+        userNightModes.forEach(userNightMode => {
+            const start = moment(userNightMode.startTime, 'HH:mm');
+            const end = moment(userNightMode.endTime, 'HH:mm');
+
+            // Nachtmodus über Mitternacht
+            if (end.isBefore(start)) {
+                if (now.isAfter(start) || now.isBefore(end)) {
+                    handleNightModeActivation(userId, userData);
+                } else {
+                    handleNightModeDeactivation(userId, userData);
+                }
+            }
+            // Normaler Nachtmodus
+            else {
+                if (now.isBetween(start, end)) {
+                    handleNightModeActivation(userId, userData);
+                } else {
+                    handleNightModeDeactivation(userId, userData);
+                }
+            }
+        });
+    }
+}
+
+// Funktion zur Aktivierung des Nachtmodus
+function handleNightModeActivation(userId, userData) {
+    if (userData[userId].notifications !== false) {
+        userData[userId].originalNotifications = userData[userId].notifications;
+        userData[userId].notifications = false;
+        saveUserData(userData);
+
+        bot.sendMessage(userId, `🌓 Der Nachtmodus hat begonnen. Deine Benachrichtigungen wurden auf Stumm geschaltet.`)
+            .then((msg) => {
+                // Pin die Nachricht
+                pinNightModeMessage(userId, msg.message_id);
+            });
+
+        console.log(`Nachtmodus für Benutzer ${userId} aktiviert.`);
+    }
+}
+
+// Funktion zur Deaktivierung des Nachtmodus
+function handleNightModeDeactivation(userId, userData) {
+    if (userData[userId].notifications === false) {
+        userData[userId].notifications = userData[userId].originalNotifications;
+        delete userData[userId].originalNotifications;
+        saveUserData(userData);
+
+        bot.sendMessage(userId, `🌓 Der Nachtmodus endet, die Benachrichtigungen sind jetzt wieder aktiv.`)
+            .then(() => {
+                // Unpin die Nachricht
+                unpinNightModeMessage(userId);
+            });
+
+        console.log(`Nachtmodus für Benutzer ${userId} deaktiviert.`);
+    }
+}
+
+// Automatische Nachtmodus-Aktivierung überwachen
+setInterval(() => {
+    activateNightMode();
+}, 60 * 1000); // Überprüfung alle 60 Sekunden
+
 // Funktion zum Erstellen der Datei 'w_offen.json' im Hauptverzeichnis, falls sie noch nicht existiert
 function ensureWOffenFileExists() {
   const filePath = path.join(__dirname, 'w_offen.json'); // Hauptverzeichnis
@@ -3347,8 +3591,8 @@ function getTypeKeyboard() {
   return {
     reply_markup: JSON.stringify({
       inline_keyboard: [
-        [{ text: 'Film', callback_data: 'type_film' }],
+        [{ text: '🎬 Film', callback_data: 'type_film' }],
-        [{ text: 'Serie', callback_data: 'type_serie' }]
+        [{ text: '📺 Serie', callback_data: 'type_serie' }]
       ]
     })
   };
@@ -3363,19 +3607,20 @@ async function sendWish(wish, type, chatId) {
     reply_markup: JSON.stringify({
       inline_keyboard: [
         [
-          { text: 'Wunsch erfüllt', callback_data: `wish_fulfilled_${chatId}` },
+          { text: '✅ Wunsch erfüllt', callback_data: `wish_fulfilled_${chatId}` },
-          { text: 'Wunsch nicht erfüllt', callback_data: `wish_not_fulfilled_${chatId}` }
+          { text: '❌ Wunsch nicht erfüllt', callback_data: `wish_not_fulfilled_${chatId}` }
         ]
       ]
     })
   };
 
   try {
-    await Promise.all([
+    const [msg1, msg2] = await Promise.all([
       bot.sendMessage(USER1_ID, message, inlineKeyboard),
       bot.sendMessage(USER2_ID, message, inlineKeyboard),
     ]);
     console.log(`Wunsch von Typ ${type} wurde an ${USER1_ID} und ${USER2_ID} gesendet.`);
+    return { messageId1: msg1.message_id, messageId2: msg2.message_id }; // Rückgabe der Nachricht IDs
   } catch (error) {
     console.error(`Fehler beim Senden des Wunsches: ${error.message}`);
   }
@@ -3392,8 +3637,12 @@ bot.on('callback_query', async (query) => {
   if (data.startsWith('type_')) {
     // Benutzer hat den Typ ausgewählt (Film oder Serie)
     const type = data === 'type_film' ? 'Film' : 'Serie';
-    bot.sendMessage(chatId, `Du hast ${type} ausgewählt. Bitte gib den Titel des ${type} ein.`)
+    await bot.sendMessage(chatId, `Du hast ${type} ausgewählt. Bitte gib den Titel des ${type} ein.`)
       .catch(error => console.error(`Fehler bei der Nachricht: ${error.message}`));
+    
+    // Lösche die Nachricht der Kategorieauswahl
+    await bot.deleteMessage(chatId, query.message.message_id).catch(error => console.error(`Fehler beim Löschen der Nachricht: ${error.message}`));
+
     userStates[chatId] = { type, waitingForWish: true }; // Setze den Status auf "wartend auf Wunsch"
   }
 
@@ -3402,7 +3651,7 @@ bot.on('callback_query', async (query) => {
     const messageText = query.message.text; // Der Text des Wunsches
     const wishTitle = messageText.split('Titel:\n')[1].trim(); // Titel korrekt extrahieren
 
-    bot.sendMessage(userId, '🎉 Dein Wunsch wurde erfüllt!')
+    await bot.sendMessage(userId, '🎉 Dein Wunsch wurde erfüllt!')
       .catch(error => console.error(`Fehler beim Senden der Nachricht: ${error.message}`));
 
     // Wunsch in der Datei 'wishes_<chatId>.json' als erfüllt markieren
@@ -3425,23 +3674,26 @@ bot.on('callback_query', async (query) => {
         });
       }
     });
+
+    // Lösche die Wunschnachricht
+    await bot.deleteMessage(chatId, query.message.message_id);
   }
 
   if (data.startsWith('wish_not_fulfilled_')) {
     const userId = query.message.chat.id; // Nutze die Chat-ID des Nachrichtenautors
-    bot.sendMessage(userId, '😢 Dein Wunsch wurde leider nicht erfüllt.')
+    await bot.sendMessage(userId, '😢 Dein Wunsch wurde leider nicht erfüllt.')
         .catch(error => console.error(`Fehler beim Senden der Nachricht: ${error.message}`));
 
     // Wunsch in der Datei 'w_offen.json' speichern
     const filePath = path.join(__dirname, 'w_offen.json');
     const wishDetails = {
-      userId,
+        userId: userId, // Chat-ID als userId speichern
-      message: query.message.text,
+        message: query.message.text, // Nachricht als Wunsch speichern
     };
 
     fs.readFile(filePath, (err, data) => {
         let openWishes = [];
-      if (!err) {
+        if (!err && data.length > 0) {
             openWishes = JSON.parse(data); // Vorhandene offene Wünsche lesen
         }
         openWishes.push(wishDetails); // Neuen offenen Wunsch hinzufügen
@@ -3454,6 +3706,9 @@ bot.on('callback_query', async (query) => {
             }
         });
     });
+
+    // Lösche die Wunschnachricht
+    await bot.deleteMessage(chatId, query.message.message_id);
   }
 
   bot.answerCallbackQuery(query.id).catch(error => {
@@ -3464,25 +3719,25 @@ bot.on('callback_query', async (query) => {
 // Verarbeite eingehende Nachrichten
 bot.on('message', async (msg) => {
   const chatId = msg.chat.id;
-  const text = msg.text;
+  const text = msg.text || ''; // Sicherstellen, dass text definiert ist
 
   if (userStates[chatId] && userStates[chatId].waitingForWish) {
     const wish = text.trim();
     if (wish) {
       const type = userStates[chatId].type;
       await sendWish(wish, type, chatId);
-      bot.sendMessage(chatId, `Dein ${type}-Wunsch wurde übermittelt.`)
+      await bot.sendMessage(chatId, `✅ Dein ${type}-Wunsch wurde übermittelt.`)
         .catch(error => console.error(`Fehler bei der Bestätigungsnachricht: ${error.message}`));
       userStates[chatId].waitingForWish = false;
     } else {
-      bot.sendMessage(chatId, `Bitte gib den Titel des ${userStates[chatId].type} ein.`)
+      await bot.sendMessage(chatId, `✍️ Bitte gib den Titel des ${userStates[chatId].type} ein.`)
         .catch(error => console.error(`Fehler bei der Wunsch-Nachricht: ${error.message}`));
     }
     return;
   }
 
   if (text.startsWith('/wunsch')) {
-    bot.sendMessage(chatId, 'Möchtest du einen Film oder eine Serie wünschen? Wähle bitte eine Option:', getTypeKeyboard())
+    await bot.sendMessage(chatId, '🎬 Möchtest du einen Film oder eine Serie wünschen? Wähle bitte eine Option:', getTypeKeyboard())
       .catch(error => console.error(`Fehler bei der Nachricht: ${error.message}`));
     userStates[chatId] = { waitingForType: true };
   }
@@ -3511,42 +3766,13 @@ bot.on('message', async (msg) => {
 // Objekt zur Verfolgung der Benutzer, die auf eine Eingabe warten
 let waitingForWishIndex = {};
 
-// Funktion zum Anzeigen aller offenen Wünsche und Inline-Button zum Markieren eines Wunsches als erfüllt
+// API-Endpunkt für offene Wünsche
-bot.onText(/\/open_wishes/, (msg) => {
+app.get('/api/wishes', (req, res) => {
-  const chatId = msg.chat.id;
+  fs.readFile('w_offen.json', 'utf8', (err, data) => {
-
+      if (err) {
-  // Pfad zur 'w_offen.json' Datei
+          return res.status(500).json({ error: 'Fehler beim Lesen der Wünsche' });
-  const filePath = path.join(__dirname, 'w_offen.json');
-
-  fs.readFile(filePath, (err, data) => {
-    if (err || data.length === 0) {
-      bot.sendMessage(chatId, 'Es gibt keine offenen Wünsche.')
-        .catch(error => console.error(`Fehler bei der Nachricht: ${error.message}`));
-    } else {
-      const openWishes = JSON.parse(data);
-      if (openWishes.length === 0) {
-        bot.sendMessage(chatId, 'Es gibt keine offenen Wünsche.')
-          .catch(error => console.error(`Fehler bei der Nachricht: ${error.message}`));
-        return;
-      }
-
-      let message = '📜 Offene Wünsche:\n\n';
-      openWishes.forEach((wish, index) => {
-        message += `${index + 1}. User ID: ${wish.userId}\n🔹 Titel: ${wish.message}\n\n`;
-      });
-
-      // Inline-Keyboard mit einem Button, um einen Wunsch als erfüllt zu markieren
-      const inlineKeyboard = {
-        reply_markup: JSON.stringify({
-          inline_keyboard: [
-            [{ text: 'Wunsch als erfüllt markieren', callback_data: 'mark_wish_fulfilled' }]
-          ]
-        })
-      };
-
-      bot.sendMessage(chatId, message, inlineKeyboard)
-        .catch(error => console.error(`Fehler bei der Nachricht: ${error.message}`));
       }
+      res.json(JSON.parse(data));
   });
 });
 
@@ -4605,6 +4831,7 @@ app.get('/api/latest-movies', async (req, res) => {
       const movies = response.data.MediaContainer.Metadata.slice(0, 10).map(movie => ({
           title: movie.title,
           coverImage: `${process.env.PLEX_DOMAIN}${movie.thumb}?X-Plex-Token=${process.env.PLEX_TOKEN}`, // Coverbild-URL mit Token
+          summary: movie.summary // Hier fügst du die Zusammenfassung hinzu
       }));
 
       console.log(movies); // Überprüfung der Daten
@@ -4795,16 +5022,49 @@ app.delete('/api/delete-faq', (req, res) => {
   }
 });
 
-// API-Endpunkt für offene Wünsche
 app.get('/api/wishes', (req, res) => {
   fs.readFile('w_offen.json', 'utf8', (err, data) => {
       if (err) {
           return res.status(500).json({ error: 'Fehler beim Lesen der Wünsche' });
       }
-      res.json(JSON.parse(data));
+      try {
+          // Hier kannst du die Logik zum Parsen der Datei manuell implementieren
+          const wishes = parseWishes(data);
+          res.json(wishes);
+      } catch (error) {
+          return res.status(500).json({ error: 'Fehler beim Verarbeiten der Wünsche' });
+      }
   });
 });
 
+// Funktion zum manuellen Parsen der nicht-standardisierten Daten
+function parseWishes(data) {
+    const wishes = [];
+    const lines = data.split('\n');
+    let currentWish = {};
+
+    for (let line of lines) {
+        if (line.startsWith('- userId:')) {
+            if (Object.keys(currentWish).length > 0) {
+                wishes.push(currentWish); // vorherigen Wunsch speichern
+            }
+            currentWish = { userId: parseInt(line.split(': ')[1]) }; // userId speichern
+        } else if (line.startsWith('message: |-')) {
+            // Nächste Zeile ist der Beginn der Nachricht
+            currentWish.message = '';
+        } else if (currentWish.message !== undefined) {
+            currentWish.message += line + '\n'; // Nachricht aufbauen
+        }
+    }
+
+    // Den letzten Wunsch hinzufügen
+    if (Object.keys(currentWish).length > 0) {
+        wishes.push(currentWish);
+    }
+
+    return wishes;
+}
+
 // Endpoint für das Feedback
 app.get('/api/feedback', (req, res) => {
   const feedbackFilePath = path.join(__dirname, 'feedback.log');
@@ -5239,62 +5499,17 @@ function sendToTelegram(report) {
 
 
 
-
-
-
 // Ende Frontend
 
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
 /// Definition der logDebug-Funktion
 function logDebug(message) {
   console.log(`${new Date().toISOString()} - DEBUG: ${message}`);
 }
 
-// Funktion zum Verarbeiten von Webhook-Anfragen
-app.post('/mywebhook', async (req, res) => {
-try {
-  const event = req.body;
-  logDebug(`Received webhook event: ${JSON.stringify(event, null, 2)}`);
 
-  if (event.type === 'library.new' && event.Metadata) {
-    const addedMovie = event.Metadata;
-    const movieTitle = addedMovie.title || 'Unbekannt';
-    const message = `Ein neuer Film wurde hinzugefügt:\n\nTitel: ${movieTitle}`;
-
-    const users = yaml.load(USER_YML_PATH);
-    const sendMessages = Object.keys(users).map(chatId =>
-      bot.sendMessage(chatId, message).catch(error => {
-        logError(`Error sending message to chatId ${chatId}: ${error.message}`);
-      })
-    );
-
-    await Promise.all(sendMessages);
-    logMessage(`Sent new movie message to all users`);
-  } else {
-    logDebug(`Unhandled event type or missing metadata: ${event.type}`);
-  }
-
-  res.sendStatus(200);
-} catch (error) {
-  logError(`Error processing webhook: ${error.message}`);
-  res.sendStatus(500);
-}
-});
 
 // Express-Server starten
 app.listen(PORT, () => {