380 lines
13 KiB
JavaScript
380 lines
13 KiB
JavaScript
const TelegramBot = require('node-telegram-bot-api');
|
|
const nodemailer = require('nodemailer');
|
|
const fs = require('fs').promises;
|
|
const yaml = require('js-yaml');
|
|
const path = require('path');
|
|
require('dotenv').config();
|
|
|
|
const emailConfig = {
|
|
user: process.env.EMAIL_USER,
|
|
pass: process.env.EMAIL_PASS,
|
|
recipient: process.env.EMAIL_RECIPIENT,
|
|
};
|
|
|
|
const botToken = process.env.BOT_TOKEN;
|
|
|
|
const botInfo = {
|
|
name: 'Telegram Support Bot',
|
|
version: '1.0.0',
|
|
author: 'M_Viper',
|
|
license: 'ISC',
|
|
};
|
|
|
|
const bot = new TelegramBot(botToken, { polling: true });
|
|
|
|
const ticketCreationStatus = new Map();
|
|
|
|
const logoPath = path.join(__dirname, 'logo.png'); // Setze den korrekten Pfad zu deinem Logo
|
|
|
|
async function loadFromYaml(filePath) {
|
|
try {
|
|
const fileContents = await fs.readFile(filePath, 'utf-8');
|
|
return yaml.load(fileContents);
|
|
} catch (error) {
|
|
console.error(`Fehler beim Laden der YAML-Datei für ${path.basename(filePath)}:`, error);
|
|
return [];
|
|
}
|
|
}
|
|
|
|
async function loadLinks() {
|
|
const linksDataPath = path.join(__dirname, 'links.yml');
|
|
return await loadFromYaml(linksDataPath);
|
|
}
|
|
|
|
async function loadTeam() {
|
|
const teamDataPath = path.join(__dirname, 'team.json');
|
|
return await loadFromYaml(teamDataPath);
|
|
}
|
|
|
|
async function loadFragen() {
|
|
const fragenDataPath = path.join(__dirname, 'fragen.yml');
|
|
return await loadFromYaml(fragenDataPath);
|
|
}
|
|
|
|
function sendWelcomeMessage(chatId) {
|
|
const welcomeMessage = `
|
|
**Willkommen beim Support!**
|
|
|
|
Herzlich willkommen! Wir schätzen es, dass Sie sich für unseren Support entschieden haben. Unser oberstes Ziel ist es, Ihnen bestmöglich zu helfen und Ihre Anliegen so schnell wie möglich zu klären. Wenn Sie Unterstützung benötigen, haben Sie verschiedene Möglichkeiten:
|
|
|
|
- Um unser Menü anzuzeigen, geben Sie einfach "/menu" ein.
|
|
- Sollte Ihre Frage nicht beantwortet werden, können Sie ganz einfach ein Ticket erstellen, um spezifische Unterstützung zu erhalten.
|
|
|
|
Wir stehen Ihnen zur Verfügung und sind hier, um Ihre Anfragen zu bearbeiten. Bitte geben Sie uns so viele Details wie möglich, damit wir Ihnen effektiv helfen können.
|
|
|
|
Vielen Dank für Ihr Vertrauen.
|
|
|
|
Herzliche Grüße,
|
|
Das Support-Team
|
|
`;
|
|
|
|
bot.sendMessage(chatId, welcomeMessage, { parse_mode: 'Markdown' });
|
|
}
|
|
|
|
async function initializeBot() {
|
|
const linksData = await loadLinks();
|
|
const teamData = await loadTeam();
|
|
const fragenData = await loadFragen();
|
|
|
|
// Hinzugefügter Abschnitt für den /info-Befehl
|
|
bot.onText(/\/info/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
console.log('Info-Befehl empfangen:', msg.text);
|
|
showBotInfo(chatId);
|
|
});
|
|
|
|
// Hinzugefügter Abschnitt für den /logo-Befehl
|
|
bot.onText(/\/logo/, (msg) => {
|
|
const chatId = msg.chat.id;
|
|
bot.sendPhoto(chatId, logoPath, { caption: 'Hier ist unser Logo!' })
|
|
.then(() => {
|
|
console.log('Logo erfolgreich gesendet.');
|
|
})
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden des Logos:', error);
|
|
});
|
|
});
|
|
|
|
bot.on('message', async (msg) => {
|
|
const chatId = msg.chat.id;
|
|
|
|
if (msg.text === '/menu') {
|
|
handleMainMenu(msg, chatId, linksData, fragenData);
|
|
return;
|
|
}
|
|
|
|
if (msg.text && msg.text.toLowerCase() === '/info') {
|
|
// /info wird nun auch über onText abgefangen
|
|
return;
|
|
}
|
|
|
|
if (ticketCreationStatus.has(chatId)) {
|
|
handleTicketCreation(msg, chatId, linksData);
|
|
return;
|
|
}
|
|
|
|
sendWelcomeMessage(chatId);
|
|
});
|
|
|
|
bot.on('callback_query', (callbackQuery) => {
|
|
const chatId = callbackQuery.message.chat.id;
|
|
const action = callbackQuery.data;
|
|
|
|
if (action === 'create_ticket') {
|
|
ticketCreationStatus.set(chatId, { step: 'waiting_for_name' });
|
|
bot.sendMessage(chatId, 'Um ein Ticket zu erstellen, gib bitte deinen Namen ein:')
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Aufforderung für den Namen:', error);
|
|
});
|
|
} else if (action === 'links') {
|
|
showLinksMenu(chatId, linksData);
|
|
} else if (action.startsWith('links_')) {
|
|
const category = action.replace('links_', '');
|
|
showLinksInCategory(chatId, category, linksData);
|
|
} else if (action === 'team') {
|
|
showTeam(chatId, teamData);
|
|
} else if (action === 'fragen') {
|
|
handleFragen(chatId, fragenData);
|
|
} else if (action.startsWith('fragen_')) {
|
|
const category = action.replace('fragen_', '');
|
|
showFragenInCategory(chatId, category, fragenData);
|
|
} else if (action.startsWith('frage_')) {
|
|
const questionId = action.replace('frage_', '');
|
|
showFrageAnswer(chatId, questionId, fragenData);
|
|
} else {
|
|
handleMainMenu(callbackQuery.message, chatId, linksData, fragenData);
|
|
}
|
|
});
|
|
|
|
bot.startPolling();
|
|
// Logging Bot Information
|
|
console.log(`
|
|
*Bot Information:*
|
|
- *Name:* ${escapeMarkdown(botInfo.name)}
|
|
- *Version:* ${escapeMarkdown(botInfo.version)}
|
|
- *Author:* ${escapeMarkdown(botInfo.author)}
|
|
- *License:* ${escapeMarkdown(botInfo.license)}
|
|
Bot ist gestartet und bereit.
|
|
`);
|
|
}
|
|
|
|
function showBotInfo(chatId) {
|
|
// Sende zuerst das Logo
|
|
bot.sendPhoto(chatId, logoPath, { caption: '*Der Bot wurde am 08.01.2024 erstellt' })
|
|
.then(() => {
|
|
// Dann sende die Bot-Informationen
|
|
const botInfoMessage = `
|
|
*Bot Information:*
|
|
- *Name:* ${escapeMarkdown(botInfo.name)}
|
|
- *Author:* ${escapeMarkdown(botInfo.author)}
|
|
- *License:* ${escapeMarkdown(botInfo.license)}
|
|
`;
|
|
|
|
return bot.sendMessage(chatId, botInfoMessage, { parse_mode: 'Markdown' });
|
|
})
|
|
.then(() => {
|
|
console.log('Bot-Informationen erfolgreich gesendet.');
|
|
})
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Bot-Info oder des Logos:', error);
|
|
});
|
|
}
|
|
|
|
function escapeMarkdown(text) {
|
|
// Funktion zum Hinzufügen von Escape-Zeichen für Markdown-Sonderzeichen
|
|
return text.replace(/[_*[\]()~`>#+-=|{}.!]/g, '\\$&');
|
|
}
|
|
|
|
function showLinksMenu(chatId, linksData) {
|
|
const linksMenuKeyboard = {
|
|
reply_markup: {
|
|
inline_keyboard: linksData.map((category) => [
|
|
{ text: category.category, callback_data: `links_${category.category}` },
|
|
]),
|
|
},
|
|
};
|
|
|
|
bot.sendMessage(chatId, 'Wähle eine Kategorie:', linksMenuKeyboard)
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Links-Menü-Tastatur:', error);
|
|
});
|
|
}
|
|
|
|
function showLinksInCategory(chatId, category, linksData) {
|
|
const categoryData = linksData.find((c) => c.category === category);
|
|
|
|
if (categoryData) {
|
|
const linksKeyboard = {
|
|
reply_markup: {
|
|
inline_keyboard: categoryData.links.map((link) => [
|
|
{ text: link.keyword, url: link.url },
|
|
]),
|
|
},
|
|
};
|
|
|
|
bot.sendMessage(chatId, `Hier sind die Links in der Kategorie '${category}':`, linksKeyboard)
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Links-Tastatur:', error);
|
|
});
|
|
} else {
|
|
bot.sendMessage(chatId, `Keine Links gefunden für die Kategorie '${category}'.`)
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Nachricht ohne Links:', error);
|
|
});
|
|
}
|
|
}
|
|
|
|
function showTeam(chatId, teamData) {
|
|
let teamMessage = 'Unser Team:\n\n';
|
|
|
|
teamData.forEach((member) => {
|
|
teamMessage += `*Name:* ${member.name}\n*Position:* ${member.position}\n*zuständig:* ${member.zustaendig}\n*Profil:* [Profil](${member.profil})\n\n`;
|
|
});
|
|
|
|
bot.sendMessage(chatId, teamMessage, { parse_mode: 'Markdown' })
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Team-Nachricht:', error);
|
|
});
|
|
}
|
|
|
|
function showFragenMenu(chatId, fragenData) {
|
|
const fragenMenuKeyboard = {
|
|
reply_markup: {
|
|
inline_keyboard: fragenData.map((category) => [
|
|
{ text: category.category, callback_data: `fragen_${category.category}` },
|
|
]),
|
|
},
|
|
};
|
|
|
|
bot.sendMessage(chatId, 'Wähle eine Kategorie:', fragenMenuKeyboard)
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Fragen-Menü-Tastatur:', error);
|
|
});
|
|
}
|
|
|
|
function showFragenInCategory(chatId, category, fragenData) {
|
|
const categoryData = fragenData.find((c) => c.category === category);
|
|
|
|
if (categoryData) {
|
|
const fragenKeyboard = {
|
|
reply_markup: {
|
|
inline_keyboard: categoryData.questions.map((frage) => [
|
|
{ text: frage.question, callback_data: `frage_${frage.id}` },
|
|
]),
|
|
},
|
|
};
|
|
|
|
bot.sendMessage(chatId, `Hier sind die Fragen in der Kategorie '${category}':`, fragenKeyboard)
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Fragen-Tastatur:', error);
|
|
});
|
|
} else {
|
|
bot.sendMessage(chatId, `Keine Fragen gefunden für die Kategorie '${category}'.`)
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Nachricht ohne Fragen:', error);
|
|
});
|
|
}
|
|
}
|
|
|
|
async function handleFragen(chatId, fragenData) {
|
|
showFragenMenu(chatId, fragenData);
|
|
}
|
|
|
|
async function showFrageAnswer(chatId, questionId, fragenData) {
|
|
const questionData = fragenData.flatMap((c) => c.questions).find((q) => q.id === questionId);
|
|
|
|
console.log('Frage-ID:', questionId);
|
|
console.log('Gefundene Frage-Daten:', questionData);
|
|
|
|
if (questionData) {
|
|
const answerMessage = `Antwort auf Frage '${questionData.question}':\n${questionData.answer}`;
|
|
bot.sendMessage(chatId, answerMessage, { parse_mode: 'Markdown' })
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Antwort auf die Frage:', error);
|
|
});
|
|
} else {
|
|
bot.sendMessage(chatId, `Keine Antwort gefunden für die Frage '${questionId}'.`)
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Nachricht ohne Antwort:', error);
|
|
});
|
|
}
|
|
}
|
|
|
|
async function handleTicketCreation(msg, chatId, linksData) {
|
|
const userId = msg.from.id;
|
|
const userStatus = ticketCreationStatus.get(chatId);
|
|
|
|
switch (userStatus.step) {
|
|
case 'waiting_for_name':
|
|
userStatus.step = 'waiting_for_email';
|
|
userStatus.name = msg.text;
|
|
bot.sendMessage(chatId, 'Danke! Bitte gib nun deine E-Mail-Adresse ein:')
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Aufforderung für den Namen:', error);
|
|
});
|
|
break;
|
|
case 'waiting_for_email':
|
|
userStatus.step = 'waiting_for_message';
|
|
userStatus.email = msg.text;
|
|
bot.sendMessage(chatId, 'Vielen Dank! Bitte schreibe jetzt deine Nachricht:')
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Aufforderung für die E-Mail:', error);
|
|
});
|
|
break;
|
|
case 'waiting_for_message':
|
|
userStatus.message = msg.text;
|
|
sendTicketEmail(chatId, userStatus);
|
|
ticketCreationStatus.delete(chatId);
|
|
bot.sendMessage(chatId, 'Vielen Dank! Dein Ticket wurde erstellt. Wir melden uns bald bei dir.')
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden der Bestätigungsnachricht für das Ticket:', error);
|
|
});
|
|
handleMainMenu(msg, chatId, linksData);
|
|
break;
|
|
}
|
|
}
|
|
|
|
const handleMainMenu = (msg, chatId, linksData, fragenData) => {
|
|
const mainMenuKeyboard = {
|
|
reply_markup: {
|
|
inline_keyboard: [
|
|
[{ text: 'Ticket erstellen', callback_data: 'create_ticket' }],
|
|
[{ text: 'Links', callback_data: 'links' }],
|
|
[{ text: 'Fragen', callback_data: 'fragen' }],
|
|
[{ text: 'Team', callback_data: 'team' }],
|
|
],
|
|
},
|
|
};
|
|
|
|
bot.sendMessage(chatId, 'Hallo! Bitte wähle eine Option:', mainMenuKeyboard)
|
|
.catch((error) => {
|
|
console.error('Fehler beim Senden des Hauptmenüs:', error);
|
|
});
|
|
};
|
|
|
|
function sendTicketEmail(chatId, ticketInfo) {
|
|
const mailOptions = {
|
|
from: `"${ticketInfo.name}" <${emailConfig.user}>`,
|
|
to: emailConfig.recipient,
|
|
subject: 'Supportanfrage',
|
|
text: `Name: ${ticketInfo.name}\nE-Mail: ${ticketInfo.email}\nNachricht: ${ticketInfo.message}`,
|
|
};
|
|
|
|
const transporter = nodemailer.createTransport({
|
|
service: 'gmail',
|
|
auth: {
|
|
user: emailConfig.user,
|
|
pass: emailConfig.pass,
|
|
},
|
|
});
|
|
|
|
transporter.sendMail(mailOptions, (error, info) => {
|
|
if (error) {
|
|
console.error('Fehler beim Senden der Ticket-E-Mail:', error);
|
|
} else {
|
|
console.log('Ticket-E-Mail erfolgreich gesendet:', info.response);
|
|
}
|
|
});
|
|
}
|
|
|
|
initializeBot(); |