Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Isnt Replying #3224

Closed
1 task done
moinihosting opened this issue Jun 28, 2024 · 3 comments
Closed
1 task done

Isnt Replying #3224

moinihosting opened this issue Jun 28, 2024 · 3 comments

Comments

@moinihosting
Copy link

Are you using the latest version of the library?

  • I have checked and am using the latest version of the library.

What type of session are you experiencing this issue on?

Multi-device and I have set multiDevice to true in my config OR am using the --multi-device flag

What type of host account are you experiencing this issue on?

Personal account (normal)

Mode

EASY API/CLI

Current Behavior

The Bot doesn´t reply

Expected Behavior

I start the Bot and he logs in. I use a Command and he isnt Replying

Steps To Reproduce

const wa = require('@open-wa/wa-automate');
const fs = require('fs');
const path = require('path');

const OWNER_NUMBERS = ['+4915752780481', '+491792911493']; // Füge hier die Telefonnummern der Owner hinzu
const APPROVAL_GROUP_ID = '[email protected]';
const SUPPORT_GROUP_ID = '[email protected]';
const LOG_GROUP_ID = '[email protected]';

let warnings = {};
let joinRequests = {}; // Speichert aktuelle Join-Anfragen
let afkStatus = {};
let activeTimers = {};

const levelDataFile = 'levelData.json';

// Lade levelData.json
let levelData = {};
if (fs.existsSync(levelDataFile)) {
levelData = JSON.parse(fs.readFileSync(levelDataFile));
}

const saveLevelData = () => {
fs.writeFileSync(levelDataFile, JSON.stringify(levelData, null, 2));
};

const enableLeveling = (groupId) => {
if (!levelData[groupId]) {
levelData[groupId] = {
members: {},
enabled: true
};
saveLevelData();
return Level-System für die Gruppe ${groupId} aktiviert;
} else if (!levelData[groupId].enabled) {
levelData[groupId].enabled = true;
saveLevelData();
return Level-System für die Gruppe ${groupId} wieder aktiviert;
} else {
return Level-System ist bereits für die Gruppe ${groupId} aktiviert;
}
};

const disableLeveling = (groupId) => {
if (levelData[groupId] && levelData[groupId].enabled) {
delete levelData[groupId];
saveLevelData();
return Level-System für die Gruppe ${groupId} deaktiviert;
} else {
return Level-System ist nicht für die Gruppe ${groupId} aktiviert;
}
};

const getLeaderboard = (groupId) => {
if (levelData[groupId] && levelData[groupId].enabled) {
const members = Object.entries(levelData[groupId].members).sort((a, b) => b[1].xp - a[1].xp);
let leaderboard = Rangliste für die Gruppe ${groupId}:\n;
members.forEach(([id, data], index) => {
leaderboard += ${index + 1}. ${id} - Level: ${data.level}, XP: ${data.xp}\n;
});
return leaderboard;
} else {
return Level-System ist nicht für die Gruppe ${groupId} aktiviert;
}
};

const getLevel = (groupId, userId) => {
if (levelData[groupId] && levelData[groupId].enabled && levelData[groupId].members[userId]) {
const user = levelData[groupId].members[userId];
return ${userId} - Level: ${user.level}, XP: ${user.xp};
} else {
return Keine Daten für Benutzer ${userId} in Gruppe ${groupId};
}
};

const addXp = (groupId, userId, xp) => {
if (levelData[groupId] && levelData[groupId].enabled) {
if (!levelData[groupId].members[userId]) {
levelData[groupId].members[userId] = { level: 1, xp: 0 };
}
levelData[groupId].members[userId].xp += xp;

    // Level-Up Logik
    const xpToNextLevel = levelData[groupId].members[userId].level * 100;
    if (levelData[groupId].members[userId].xp >= xpToNextLevel) {
        levelData[groupId].members[userId].level++;
        levelData[groupId].members[userId].xp -= xpToNextLevel;
    }

    saveLevelData();
    return `Benutzer ${userId} hat jetzt Level ${levelData[groupId].members[userId].level} mit ${levelData[groupId].members[userId].xp} XP`;
} else {
    return `Level-System ist nicht für die Gruppe ${groupId} aktiviert`;
}

};

const BannedNumbers = [
"[email protected]"
];
const isBanned = (userId) => {
return BannedNumbers.includes(userId);
};

const RATINGS_FILE = 'bewertungen.json';

// Initialisiere die Bewertungen, falls die Datei nicht existiert
if (!fs.existsSync(RATINGS_FILE)) {
fs.writeFileSync(RATINGS_FILE, JSON.stringify({}));
}

if (fs.existsSync('warnings.json')) {
warnings = JSON.parse(fs.readFileSync('warnings.json', 'utf8'));
}

if (fs.existsSync('afk.json')) {
afkStatus = JSON.parse(fs.readFileSync('afk.json', 'utf8'));
}

if (fs.existsSync('bans.json')) {
banned = JSON.parse(fs.readFileSync('bans.json', 'utf-8'));
}

function saveAntilinkConfig() {
fs.writeFileSync(ANTILINK_FILE_PATH, JSON.stringify(antilinkConfig, null, 2));
}

// Funktion zum Hinzufügen einer Gruppe zum Antilink-System
function enableAntilink(groupId) {
const existingGroup = antilinkConfig.groups.find(group => group.groupId === groupId);
if (existingGroup) {
existingGroup.enabled = true;
} else {
antilinkConfig.groups.push({ groupId, enabled: true });
}
saveAntilinkConfig();
}

// Funktion zum Entfernen einer Gruppe aus dem Antilink-System
function disableAntilink(groupId) {
antilinkConfig.groups = antilinkConfig.groups.filter(group => group.groupId !== groupId);
saveAntilinkConfig();
}

// Funktion zum Überprüfen, ob das Antilink-System für eine Gruppe aktiviert ist
function isAntilinkEnabled(groupId) {
const group = antilinkConfig.groups.find(group => group.groupId === groupId);
return group ? group.enabled : false;
}

const commandEnable = async (client, message) => {
const response = enableLeveling(message.from);
await client.sendText(message.from, response);
};

const commandDisable = async (client, message) => {
const response = disableLeveling(message.from);
await client.sendText(message.from, response);
};

const commandLeaderboard = async (client, message) => {
const response = getLeaderboard(message.from);
await client.sendText(message.from, response);
};

const commandLevel = async (client, message, senderId) => {
const response = getLevel(message.from, senderId);
await client.sendText(message.from, response);
};

const REPORT_GROUP_ID = '[email protected]';

wa.create({
sessionId: "Sommerzeit",
multiDevice: true,
authTimeout: 60,
blockCrashLogs: true,
disableSpins: true,
headless: true,
hostNotificationLang: 'PT_BR',
logConsole: false,
popup: true,
qrTimeout: 0,
}).then(client => {
start(client);
});

function start(client) {
client.onMessage(async message => {
if (message.body.startsWith('/')) {
const args = message.body.slice(1).trim().split(/ +/);
const command = args.shift().toLowerCase();
const from = message.from;
const sender = message.sender.id;
const groupId = message.chatId;
const isOwner = OWNER_NUMBERS.includes(sender);
const isAdmin = await client.getGroupAdmins(groupId).then(admins => admins.includes(sender));

  if (isOwner) {
    handleOwnerCommands(client, message, command, args);
  } else if (isAdmin) {
    handleAdminCommands(client, message, command, args);
  } else {
    handleUserCommands(client, message, command, args);
  }
}

});

function handleOwnerCommands(client, message, command, args) {
switch (command) {
case 'group-leave':
groupLeave(client, message);
break;
case 'addadmin':
addAdmin(client, message, args);
break;
case 'botban':
permaBotBan(client, message, args)
default:
client.sendText(message.from, Unbekannter Owner-Befehl: ${command});
}
}

function handleAdminCommands(client, message, command, args) {
switch (command) {
case 'warn':
warnUser(client, message, args);
break;
case 'kick':
kickUser(client, message, args);
break;
case 'help':
sendHelpMessage(client, message);
break;
case 'say':
echoMessage(client, message, args.join(' '));
break;
case 'info':
sendInfoMessage(client, message);
break;
case 'wetter':
sendWeatherMessage(client, message, args.join(' '));
break;
case 'session':
showSession(client, message);
break;
case 'owners':
showOwners(client, message);
break;
case 'joinreq':
handleJoinRequest(client, message, args);
break;
case 'trash':
sendTrashMessage(client, message, args);
break;
case 'fuck':
sendFuckMessage(client, message, args);
break;
case 'myinfo':
sendMyInfo(client, message)
case 'tipp':
sendTipMessage(client, message);
break;
case 'starttimer':
startTimer(client, message, args);
break;
case 'stoptimer':
stopTimer(client, message, args);
break;
case 'wave':
sendWaveMessage(client, message, args);
break;
case 'poop':
sendPoopMessage(client, message);
break;
case 'question':
sendRandomQuestion(client, message);
break;
case 'emoji':
sendRandomEmojis(client, message);
break;
case 'slap':
slapUser(client, message, args);
break;
case 'nandukek':
nichtkek(client, message);
break;
case 'ping':
pingmsg(client, message);
break;
case '8ball':
eightBall(client, message);
break;
case 'roll':
diceroll(client, message, args);
break;
case 'coinflip':
coinFlip(client, message);
break;
case 'antilink-enable':
const groupIdToEnable = message.chatId; // oder args[0] für eine spezifische Gruppen-ID
enableAntilink(groupIdToEnable);
client.sendText(message.from, Antilink wurde für die Gruppe aktiviert.);
break;
case 'antilink-disable':
const groupIdToDisable = message.chatId; // oder args[0] für eine spezifische Gruppen-ID
disableAntilink(groupIdToDisable);
client.sendText(message.from, Antilink wurde für die Gruppe deaktiviert.);
break;
case 'kickme':
kickself(client, message);
break;
case 'sticker':
createSticker(client, message);
break;
case 'report':
sendReport(client, message);
break;
case 'support':
handleSupportCommand(client, message);
break;
case 'bewerten':
handleRateCommand(client, message);
break;
case 'bewertungen':
handleRatingsCommand(client, message);
break;
case 'leveling-enable':
commandEnable(client, message);
break;
case 'leveling-disable':
commandDisable(client, message);
break;
case 'lb':
commandLeaderboard(client, message);
break;
case 'level':
commandLevel(client, message);
break;
case 'cookie':
sendCookieMessage(client, message, args);
break;
default:
client.sendText(message.from, Unbekannter Admin-Befehl: ${command});
}
}

function handleUserCommands(client, message, command, args) {
switch (command) {
case 'help':
sendHelpMessage(client, message);
break;
case 'say':
echoMessage(client, message, args.join(' '));
break;
case 'info':
sendInfoMessage(client, message);
break;
case 'wetter':
sendWeatherMessage(client, message, args.join(' '));
break;
case 'session':
showSession(client, message);
break;
case 'owners':
showOwners(client, message);
break;
case 'joinreq':
handleJoinRequest(client, message, args);
break;
case 'trash':
sendTrashMessage(client, message, args);
break;
case 'fuck':
sendFuckMessage(client, message, args);
break;
case 'myinfo':
sendMyInfo(client, message)
case 'tipp':
sendTipMessage(client, message);
break;
case 'starttimer':
startTimer(client, message, args);
break;
case 'stoptimer':
stopTimer(client, message, args);
break;
case 'wave':
sendWaveMessage(client, message, args);
break;
case 'poop':
sendPoopMessage(client, message);
break;
case 'question':
sendRandomQuestion(client, message);
break;
case 'emoji':
sendRandomEmojis(client, message);
break;
case 'slap':
slapUser(client, message, args);
break;
case 'nandukek':
nichtkek(client, message);
break;
case 'ping':
pingmsg(client, message);
break;
case '8ball':
eightBall(client, message);
break;
case 'roll':
diceroll(client, message, args);
break;
case 'coinflip':
coinFlip(client, message);
break;
case 'kickme':
kickself(client, message);
break;
case 'sticker':
createSticker(client, message);
break;
case 'report':
sendReport(client, message);
break;
case 'support':
handleSupportCommand(client, message);
break;
case 'bewerten':
handleRateCommand(client, message);
break;
case 'bewertungen':
handleRatingsCommand(client, message);
break;
case 'lb':
commandLeaderboard(client, message);
break;
case 'level':
commandLevel(client, message);
break;
case 'cookie':
sendCookieMessage(client, message, args);
break;
default:
client.sendText(message.from, Unbekannter Befehl: ${command});
}
client.onMessage(async message => {

  const groupId = message.chatId;
  const joinRequest = Object.keys(joinRequests).find(link => joinRequests[link].requester === groupId);

  if (joinRequest && message.body.toLowerCase() === 'ja') {
    try {
      await client.joinGroupViaLink(joinRequest);
      client.sendText(APPROVAL_GROUP_ID, `Der Bot ist der Gruppe auf Anfrage von @${joinRequests[joinRequest].requester.split('@')[0]} beigetreten.`);
      delete joinRequests[joinRequest];
    } catch (error) {
      client.sendText(APPROVAL_GROUP_ID, `Fehler beim Beitreten der Gruppe: ${error.message}`);
    }
  }
  
  });

}

function sendWaveMessage(client, message, args) {
const target = args.join(' ');

if (!target) {
  client.sendText(message.from, 'Bitte geben Sie den Namen der Person an, der Sie winken möchten. Beispiel: !wave <Name>');
  return;
}

client.sendText(message.from, `👋 ${target}, ${message.sender.pushname} winkt dir zu!`);

}

async function createSticker(client, message) {
const mediaData = await client.downloadMediaMessage(message);
await client.sendImageAsSticker(from, mediaData, {
author: 'Made By',
pack: 'Dino',
});

}

async function handleRateCommand(client, message) {
const { from, body, sender } = message;
const [command, rateUserMention, ratingRaw] = body.split(' ');

// Extrahiere die Benutzer-ID aus der Erwähnung
const rateUserId = rateUserMention.slice(9).trim();
const rating = parseInt(ratingRaw);

// Überprüfen, ob die Bewertung gültig ist
if (!rateUserId || isNaN(rating) || rating < 1 || rating > 5) {
  await client.sendText(from, 'Verwendung: !bewerten <@nummer> <1-5>');
  return;
}

// Bewertungen laden
let ratings = {};
if (fs.existsSync(RATINGS_FILE)) {
  ratings = JSON.parse(fs.readFileSync(RATINGS_FILE, 'utf8'));
}

// Überprüfen, ob der Benutzer bereits bewertet wurde
if (!ratings[rateUserId]) {
  ratings[rateUserId] = {
    totalStars: rating,
    numRatings: 1
  };
} else {
  // Benutzer wurde bereits bewertet, aktualisiere die Bewertungen
  ratings[rateUserId].totalStars += rating;
  ratings[rateUserId].numRatings++;
}

// Aktualisierte Daten in die Datei schreiben
fs.writeFileSync(RATINGS_FILE, JSON.stringify(ratings));

await client.sendText(from, `Benutzer ${rateUserMention} wurde mit ${rating} Sternen bewertet.`);

}

// Funktion, um die Bestenliste der Bewertungen anzuzeigen
async function handleRatingsCommand(client, message) {
const { from } = message;

// Bewertungen laden
let ratings = {};
if (fs.existsSync(RATINGS_FILE)) {
  ratings = JSON.parse(fs.readFileSync(RATINGS_FILE, 'utf8'));
}

// Berechne den Durchschnitt der Bewertungen für jeden Benutzer
const averageRatings = Object.keys(ratings).map(userId => {
  const userRatings = ratings[userId];
  const averageRating = userRatings.totalStars / userRatings.numRatings;
  return {
    userId: userId.includes('@c.us') ? userId : `+${userId}`,
    averageRating,
    numRatings: userRatings.numRatings
  };
});

// Sortiere nach dem durchschnittlichen Bewertungslevel und Anzahl der Bewertungen
averageRatings.sort((a, b) => b.averageRating - a.averageRating || b.numRatings - a.numRatings);

// Erstelle die Antwortnachricht
let responseMessage = 'Top-Bewertungen:\n';
averageRatings.slice(0, 10).forEach((user, index) => {
  responseMessage += `${index + 1}. ${user.userId} : ${user.averageRating.toFixed(2)} Sterne (${user.numRatings} Bewertungen)\n`;
});

await client.sendText(from, responseMessage);

}

function slapUser(client, message, args) {
const target = args.join(' ');

if (!target) {
  client.sendText(message.from, 'Bitte gib an, wen du schlagen möchtest. Beispiel: !slap @Zielname');
  return;
}

const responseText = `${message.sender.pushname} hat ${target} auf den Arsch geschlagen 🍑`;
client.sendText(message.from, responseText);

}

function permaBotBan(client, message, args) {
client.sendText(message.from, 'Dieser Befehl ist in Wartung!')
}

async function handleSupportCommand(client, message) {
const { from, body, sender } = message;
const supportMessage = body.slice(9).trim();
if (supportMessage) {
await client.sendText(SUPPORT_GROUP_ID, Neue Support-Anfrage von ${sender.id}:\n\n${supportMessage});
await client.sendText(from, 'Deine Support-Anfrage wurde gesendet.');
} else {
await client.sendText(from, 'Bitte gib eine Nachricht an, die du für den Support senden möchtest.');
}
}

function sendTipMessage(client, message) {
const tips = [
"Trinke jeden Tag genug Wasser!",
"Mache regelmäßige Pausen während der Arbeit.",
"Lerne jeden Tag etwas Neues.",
"Bewege dich regelmäßig und halte dich fit.",
"Lese Bücher, um deinen Geist zu erweitern.",
"Schlafe ausreichend, um erholt zu sein.",
"Verbringe Zeit mit Familie und Freunden.",
"Halte dein Zuhause und deinen Arbeitsplatz ordentlich.",
"Meditiere, um Stress abzubauen.",
"Plane deine Aufgaben, um organisiert zu bleiben."
];

const randomTip = tips[Math.floor(Math.random() * tips.length)];

const tipMessage = `
*── 「 💡 Tipp des Tages 」 ──*
➸ ${randomTip}
`;

client.sendText(message.from, tipMessage);

}

function sendHelpMessage(client, message) {
const helpText = *📚 Hilfe - Verfügbare Befehle:* 1. *!help* - Zeigt diese Hilfenachricht an 2. *!say <Nachricht>* - Wiederholt die Nachricht 3. *!info* - Zeigt Informationen über den Bot 4. *!wetter <Ort>* - Zeigt das Wetter für den angegebenen Ort an 5. *!session* - Zeigt die Aktuelle Session an. 6. *!owners* - Zeigt alle Owner an 7. *!joinreq <Gruppenlink>* - Erstellt eine Beitrittsanfrage 8. *!trash* - Steck jemmanden in den Müll 9. *!fuck* - Fuck jemmanden 10. *!tipp* - Sendet einen Tipp des Tages 11. *!starttimer <Name> <Zeit_in_Sekunden>* - Startet einen Timer 12. *!stoptimer <Name>* - Stoppt einen Timer 13. *!myinfo* - Zeigt deine Info 14. *!wave <Name>* - Winkt jemanden 15. *!poop* - Sendet ein Haufen 16. *!question* - Fragt dich etwas 17. *!emoji* - Sendet ein Random Emoji 18. *!slap* - Slage einen Random Nutzer 19. *!ping* - Zeigt den Aktuellen Ping an 20. *!8ball* - Sagt dir eine Random Antwort 21. *!roll* - Würfel den Würfel 22. *!coinflip* - Flippe eine Münze 23. *!antilink-enable* - Aktiviere das Anti-Link System 24. *!antilink-disable* - Deaktiviere das Anti-Link System 25. *!kickme* - Kick dich selber 26. *!sticker* - Erstelle mit einem Bild ein Sticker 27. *!report* - Melde einen Nutzer, eine Gruppe etc. 28. *!support* - Frage Support an. 29. *!bewerten* - Bewerte einen nutzer von 1 - 5 30. *!bewertungen* - Zeigt deine Bewertungen 31. *!leveling-enable* - Aktiviere das Leveling System 32. *!leveling-disable* - Deaktiviere das Leveling System 33. *!lb* - Schau dir das Leaderboard der Gruppe an 34. *!level* - Schau dir dein Aktuelles Level an;
client.sendText(message.from, helpText);
}

function mainMenu(client, message) {
const mainMenuText =
}

async function sendReport(client, message) {
try {
const reportContent = message.body.slice(8).trim(); // Entfernt das Kommando "!report" und Leerzeichen
if (reportContent) {
const reportMessage = Neuer Bericht von ${message.sender.pushname} (${message.from}):\n\n${reportContent};
await client.sendText(REPORT_GROUP_ID, reportMessage);
await client.sendText(message.from, 'Dein Bericht wurde erfolgreich gesendet!');
} else {
await client.sendText(message.from, 'Bitte geben Sie einen Berichtstext nach dem Befehl "!report" ein.');
}
} catch (err) {
console.error('Fehler beim Senden des Berichts:', err);
await client.sendText(message.from, 'Entschuldigung, es gab einen Fehler beim Senden deines Berichts.');
}
}

function senduserid(client, message) {
console.log(message.sender.id);
}

function kickself (client, message) {
const kicker = message.author
client.sendText(message.from, 'BB mein Lieber.');
client.removeParticipant(message.chatId, kicker);
}

function eightBall(client, message) {
const responses = [
'Ja',
'Nein',
'Vielleicht',
'Frag später nochmal',
'Besser nicht',
'Auf jeden Fall!',
'Absolut nicht'
];
const randomResponse = responses[Math.floor(Math.random() * responses.length)];
client.sendText(message.from, Frage: ${message.body.slice(7).trim()}\nAntwort: ${randomResponse});
}

function diceroll(client, message, args) {
const max = parseInt(args[0]) || 6; // Standardmäßig auf 6 setzen, wenn keine Zahl angegeben ist
const randomNumber = Math.floor(Math.random() * max) + 1;
client.sendText(message.from, 🎲 Du hast eine ${randomNumber} gewürfelt (1-${max}));
}

function coinFlip(client, message) {
const result = Math.random() < 0.5 ? 'Kopf' : 'Zahl';
client.sendText(message.from, Münzwurf: ${result});
}

function nichtkek(client, message) {
client.sendText(message.from, 'Hey! Nenn mich nicht nicht so!');
}

function stopTimer(client, message, args) {
const timerName = args[0];

if (!timerName || !activeTimers[timerName]) {
  client.sendText(message.from, `Es läuft kein Timer mit dem Namen "${timerName}".`);
  return;
}

clearTimeout(activeTimers[timerName]);
delete activeTimers[timerName];
client.sendText(message.from, `⏱️ Timer "${timerName}" wurde gestoppt.`);

}

function pingmsg(client, message) {
const start = Date.now();
client.sendText(message.from, 'Pong! 🏓').then(() => {
const end = Date.now();
const latency = end - start;
client.sendText(message.from, Ping: ${latency}ms);
}).catch(err => {
console.error('Fehler beim Senden der Ping-Nachricht:', err);
});
}

function sendRandomEmojis(client, message) {
const emojis = [
'😄', '😊', '😁', '😍', '🥳', '😎', '🤩', '😜', '🤗', '😇',
'🤔', '🙃', '😉', '🤓', '🥰', '😋', '😂', '😅', '🤣', '😆',
'😮‍💨', '😮‍💨', '😲', '😯', '😵‍💫', '😵‍💫', '🥸', '🤭', '🤫', '🤥'
];

let randomEmojis = '';
for (let i = 0; i < 5; i++) {
  const randomIndex = Math.floor(Math.random() * emojis.length);
  randomEmojis += emojis[randomIndex] + ' ';
}

client.sendText(message.from, `🎉 Hier sind 5 zufällige Emojis für dich:\n${randomEmojis}`);

}

function sendPoopMessage(client, message) {
client.sendText(message.from, 💩 *Plop!* Hier kommt das Häufchen von ${message.sender.pushname} 💩);
}

function sendRandomQuestion(client, message) {
const questions = [
"Was war das lustigste Erlebnis deiner Kindheit?",
"Wenn du einen Tag lang unsichtbar wärst, was würdest du tun?",
"Was ist deine Lieblingsspeise und warum?",
"Welche Fähigkeit würdest du gerne erlernen, wenn du alles könntest?",
"Wenn du in der Zeit zurückreisen könntest, in welche Epoche würdest du gehen?",
"Was ist dein Lieblingsfilm und warum gefällt er dir so gut?",
"Wenn du ein Tier sein könntest, welches wärst du und warum?",
"Was war das beste Geschenk, das du jemals erhalten hast?",
"Wenn du einen Superhelden als besten Freund haben könntest, wer wäre es?",
"Was ist deine liebste Freizeitbeschäftigung und warum macht sie dir Spaß?"
];

const randomIndex = Math.floor(Math.random() * questions.length);
const randomQuestion = questions[randomIndex];

client.sendText(message.from, `🤔 Hier ist eine Frage für dich:\n${randomQuestion}`);

}

function startTimer(client, message, args) {
const timerName = args[0];
const duration = parseInt(args[1]); // In Sekunden

if (!timerName || isNaN(duration) || duration <= 0) {
  client.sendText(message.from, 'Ungültige Verwendung! Beispiel: !starttimer <Name> <Zeit_in_Sekunden>');
  return;
}

if (activeTimers[timerName]) {
  client.sendText(message.from, `Ein Timer mit dem Namen "${timerName}" läuft bereits.`);
  return;
}

activeTimers[timerName] = setTimeout(() => {
  client.sendText(message.from, `⏰ Timer "${timerName}" ist abgelaufen!`);
  delete activeTimers[timerName];
}, duration * 1000);

client.sendText(message.from, `⏱️ Timer "${timerName}" gestartet für ${duration} Sekunden.`);

}

async function sendMyInfo(client, message) {
if (!message.sender) {
client.sendText(message.from, 'Fehler: Absenderinformationen fehlen.');
return;
}

const senderId = message.sender.id;
const senderName = message.sender.pushname || 'Unbekannt';
const senderNumber = senderId.split('@')[0];
const groupId = message.chatId;
const isAdmin = await client.getGroupAdmins(groupId).then(admins => admins.includes(senderId));

const infoText = `
  *── 「 📋 Deine Informationen 」 ──*
  ➸ *Name:* ${senderName}
  ➸ *Nummer:* ${senderNumber}
  ➸ *Rolle:* ${isAdmin ? 'Admin' : 'Mitglied'}
`;

client.sendText(message.from, infoText);

}

function setAfkStatus(client, message, args) {
const groupId = message.chatId;
const senderId = message.sender.id;
const reason = args.join(' ') || 'AFK';

if (!afkStatus[groupId]) {
  afkStatus[groupId] = {};
}

afkStatus[groupId][senderId] = {
  reason: reason,
  timestamp: new Date().toISOString()
};

fs.writeFileSync('afk.json', JSON.stringify(afkStatus, null, 2));
client.sendText(message.from, `Du bist jetzt als AFK markiert. Grund: ${reason}`);

}

async function checkAfkStatus(client, message) {
if (!message.sender) {
return;
}

const groupId = message.chatId;
const senderId = message.sender.id;

if (afkStatus[groupId] && afkStatus[groupId][senderId]) {
  const reason = afkStatus[groupId][senderId].reason;
  delete afkStatus[groupId][senderId];
  fs.writeFileSync('afk.json', JSON.stringify(afkStatus, null, 2));
  client.sendText(message.from, `Willkommen zurück, ${message.sender.pushname}! Du warst AFK. Grund: ${reason}`);
}

}

function showSession(client, message) {
const sessionText = *── 「 Session 」 ──* Das sind die Sessions. ➸ SessionID: Sommerzeit ➸ Bot Owner: Damian Schönberger;
client.sendText(message.from, sessionText);
}

function showOwners(client, message) {
const ownermessage = *── 「 Owner 」 ──* Das sind alle Bot Owner ➸ Damian +491787157956;
client.sendText(message.from, ownermessage);
}

function echoMessage(client, message, text) {
client.sendText(message.from, 🔁 ${text});
}

function sendInfoMessage(client, message) {
const infoText = *── 「 Bot Infos 」 ──* ➸ Version: 1.0.0 ➸ Entwickler: Damian Schönberger ➸ Beschreibung: Dies ist ein nützlicher Öffentlicher WhatsApp Bot;
client.sendText(message.from, infoText);
}

function getWeather(location) {
return Promise.resolve(Das Wetter in ${location}: 🌞 Sonnig, 25°C);
}

function sendWeatherMessage(client, message, location) {
getWeather(location).then(weatherInfo => {
client.sendText(message.from, 🌤 Wetterinformation:\n${weatherInfo});
}).catch(error => {
client.sendText(message.from, Fehler beim Abrufen der Wetterdaten: ${error.message});
});
}

function groupLeave(client, message) {
const groupId = message.chatId;
try {
client.sendText(groupId, 'Ich verlasse die Gruppe auf Anweisung des Owners.');
client.leaveGroup(groupId);
client.deleteChat(groupId);
console.log(Bot hat Gruppe ${groupId} verlassen.);
} catch (error) {
console.error(Fehler beim Verlassen der Gruppe ${groupId}: ${error});
}
}

function warnUser(client, message, args) {
const userToWarn = args[0];
const groupId = message.chatId;

if (!warnings[groupId]) {
  warnings[groupId] = {};
}

if (!warnings[groupId][userToWarn]) {
  warnings[groupId][userToWarn] = 0;
}

warnings[groupId][userToWarn] += 1;
fs.writeFileSync('warnings.json', JSON.stringify(warnings));

client.sendText(groupId, `${userToWarn} hat nun ${warnings[groupId][userToWarn]} Warnung(en).`);

if (warnings[groupId][userToWarn] >= 3) {
  client.sendText(groupId, `${userToWarn} hat 3 Warnungen erhalten und wird nun aus der Gruppe entfernt.`);
  kickUser(client, { chatId: groupId, sender: { id: userToWarn } });
}

}

function kickUser(client, message, args) {
const userToKick = args.length > 0 ? args[0] : message.sender.id;
client.removeParticipant(message.chatId, userToKick).then(() => {
client.sendText(message.chatId, ${userToKick} wurde aus der Gruppe entfernt.);
}).catch(err => {
client.sendText(message.chatId, Fehler beim Entfernen des Benutzers: ${err.message});
});
}

function addAdmin(client, message, args) {
const newAdmin = args[0];
// Hier kannst du die Logik hinzufügen, um einen neuen Admin hinzuzufügen
// Z.B.: ADMIN_NUMBERS.push(newAdmin);
client.sendText(message.from, ${newAdmin} wurde als Admin hinzugefügt.);
}

function handleJoinRequest(client, message, args) {
const groupLink = args[0];
const requestingUser = message.sender.id;

if (!groupLink) {
  client.sendText(message.from, 'Bitte geben Sie einen Gruppenlink an. Beispiel: !joinreq https://chat.whatsapp.com/...');
  return;
}

joinRequests[groupLink] = { requester: requestingUser, requestedAt: new Date() };
client.sendText(APPROVAL_GROUP_ID, `📢 Beitrittsanfrage von ${message.sender.pushname} (@${requestingUser.split('@')[0]}).\nGruppe: ${groupLink}\nBitte antworten Sie mit "ja" um den Bot beitreten zu lassen.`);

}

function sendFuckMessage(client, message, args) {
if (!args || args.length === 0) {
client.sendText(message.from, 'Bitte geben Sie einen Nutzer oder ein Ziel an.');
return;
}

const target = args.join(' ');
const senderName = message.sender.pushname || 'Jemmanden';

const responseText = `💢 ${senderName} fickt ${target}!`;
client.sendText(message.from, responseText);

}

function sendCookieMessage(client, message, args) {
if (!args || args.length === 0) {
client.sendText(message.from, 'Bitte geben Sie einen Nutzer oder ein Ziel an.');
return;
}

const target = args.join(' ');
const senderName = message.sender.pushname || 'Jemanden';

const responseText = `🍪 ${senderName} gibt ${target} ein Cookie!`;
client.sendText(message.from, responseText);

}

function sendTrashMessage(client, message, args) {
if (!args || args.length === 0) {
client.sendText(message.from, 'Bitte geben Sie einen Nutzer oder ein Ziel an.');
return;
}

const target = args.join(' ');
const senderName = message.sender.pushname || 'Jemanden';

const responseText = `🗑️ ${senderName} steckt ${target} in den Müll.`;
client.sendText(message.from, responseText);

}
}

create() code OR full CLI command + CONFIG

wa.create({
  sessionId: "Sommerzeit",
  multiDevice: true,
  authTimeout: 60,
  blockCrashLogs: true,
  disableSpins: true,
  headless: true,
  hostNotificationLang: 'PT_BR',
  logConsole: false,
  popup: true,
  qrTimeout: 0,
}).then(client => {
  start(client);
});

function start(client) {
  client.onMessage(async message => {
    if (message.body.startsWith('/')) {
      const args = message.body.slice(1).trim().split(/ +/);
      const command = args.shift().toLowerCase();
      const from = message.from;
      const sender = message.sender.id;
      const groupId = message.chatId;
      const isOwner = OWNER_NUMBERS.includes(sender);
      const isAdmin = await client.getGroupAdmins(groupId).then(admins => admins.includes(sender));

      if (isOwner) {
        handleOwnerCommands(client, message, command, args);
      } else if (isAdmin) {
        handleAdminCommands(client, message, command, args);
      } else {
        handleUserCommands(client, message, command, args);
      }
    }
  });

  function handleOwnerCommands(client, message, command, args) {
    switch (command) {
      case 'group-leave':
        groupLeave(client, message);
        break;
      case 'addadmin':
        addAdmin(client, message, args);
        break;
      case 'botban':
        permaBotBan(client, message, args)
      default:
        client.sendText(message.from, `Unbekannter Owner-Befehl: ${command}`);
    }
  }

  function handleAdminCommands(client, message, command, args) {
    switch (command) {
      case 'warn':
        warnUser(client, message, args);
        break;
      case 'kick':
        kickUser(client, message, args);
        break;
        case 'help':
        sendHelpMessage(client, message);
        break;
      case 'say':
        echoMessage(client, message, args.join(' '));
        break;
      case 'info':
        sendInfoMessage(client, message);
        break;
      case 'wetter':
        sendWeatherMessage(client, message, args.join(' '));
        break;
      case 'session':
        showSession(client, message);
        break;
      case 'owners':
        showOwners(client, message);
        break;
      case 'joinreq':
        handleJoinRequest(client, message, args);
        break;
      case 'trash':
        sendTrashMessage(client, message, args);
        break;
      case 'fuck':
        sendFuckMessage(client, message, args);
        break;
       case 'myinfo':
        sendMyInfo(client, message)
        case 'tipp':
         sendTipMessage(client, message);
         break;
      case 'starttimer':
        startTimer(client, message, args);
        break;
      case 'stoptimer':
        stopTimer(client, message, args);
        break;
      case 'wave':
        sendWaveMessage(client, message, args);
        break;
      case 'poop':
        sendPoopMessage(client, message);
        break;
      case 'question':
        sendRandomQuestion(client, message);
        break;
      case 'emoji':
        sendRandomEmojis(client, message);
        break;
      case 'slap':
        slapUser(client, message, args); 
        break;
      case 'nandukek':
        nichtkek(client, message);
        break;
      case 'ping':
        pingmsg(client, message);
        break;
      case '8ball':
        eightBall(client, message);
        break;
      case 'roll':
        diceroll(client, message, args);
        break;
      case 'coinflip':
        coinFlip(client, message);
        break;
        case 'antilink-enable':
          const groupIdToEnable = message.chatId; // oder args[0] für eine spezifische Gruppen-ID
          enableAntilink(groupIdToEnable);
          client.sendText(message.from, `Antilink wurde für die Gruppe aktiviert.`);
          break;
        case 'antilink-disable':
          const groupIdToDisable = message.chatId; // oder args[0] für eine spezifische Gruppen-ID
          disableAntilink(groupIdToDisable);
          client.sendText(message.from, `Antilink wurde für die Gruppe deaktiviert.`);
          break;
        case 'kickme':
          kickself(client, message);
          break;
        case 'sticker':
         createSticker(client, message);
         break;
         case 'report':
          sendReport(client, message);
          break;
        case 'support':
          handleSupportCommand(client, message);
          break;
        case 'bewerten':
          handleRateCommand(client, message);
          break;
          case 'bewertungen':
            handleRatingsCommand(client, message);
            break;
        case 'leveling-enable':
          commandEnable(client, message);
          break;
        case 'leveling-disable':
          commandDisable(client, message);
          break;
        case 'lb':
          commandLeaderboard(client, message);
          break;
        case 'level':
          commandLevel(client, message);
          break;
        case 'cookie':
          sendCookieMessage(client, message, args);
          break;
        default:
        client.sendText(message.from, `Unbekannter Admin-Befehl: ${command}`);
    }
  }

  function handleUserCommands(client, message, command, args) {
    switch (command) {
      case 'help':
        sendHelpMessage(client, message);
        break;
      case 'say':
        echoMessage(client, message, args.join(' '));
        break;
      case 'info':
        sendInfoMessage(client, message);
        break;
      case 'wetter':
        sendWeatherMessage(client, message, args.join(' '));
        break;
      case 'session':
        showSession(client, message);
        break;
      case 'owners':
        showOwners(client, message);
        break;
      case 'joinreq':
        handleJoinRequest(client, message, args);
        break;
      case 'trash':
        sendTrashMessage(client, message, args);
        break;
      case 'fuck':
        sendFuckMessage(client, message, args);
        break;
       case 'myinfo':
        sendMyInfo(client, message)
        case 'tipp':
         sendTipMessage(client, message);
         break;
      case 'starttimer':
        startTimer(client, message, args);
        break;
      case 'stoptimer':
        stopTimer(client, message, args);
        break;
      case 'wave':
        sendWaveMessage(client, message, args);
        break;
      case 'poop':
        sendPoopMessage(client, message);
        break;
      case 'question':
        sendRandomQuestion(client, message);
        break;
      case 'emoji':
        sendRandomEmojis(client, message);
        break;
      case 'slap':
        slapUser(client, message, args); 
        break;
      case 'nandukek':
        nichtkek(client, message);
        break;
      case 'ping':
        pingmsg(client, message);
        break;
      case '8ball':
        eightBall(client, message);
        break;
      case 'roll':
        diceroll(client, message, args);
        break;
      case 'coinflip':
        coinFlip(client, message);
        break;
      case 'kickme':
        kickself(client, message);
        break;
      case 'sticker':
        createSticker(client, message);
        break;
      case 'report':
        sendReport(client, message);
        break;
      case 'support':
        handleSupportCommand(client, message);
        break;
      case 'bewerten':
        handleRateCommand(client, message);
        break;
      case 'bewertungen':
        handleRatingsCommand(client, message);
        break;
      case 'lb':
        commandLeaderboard(client, message);
        break;
      case 'level':
        commandLevel(client, message);
        break;
      case 'cookie':
        sendCookieMessage(client, message, args);
        break;
      default:
        client.sendText(message.from, `Unbekannter Befehl: ${command}`);
    }
    client.onMessage(async message => {


      const groupId = message.chatId;
      const joinRequest = Object.keys(joinRequests).find(link => joinRequests[link].requester === groupId);
  
      if (joinRequest && message.body.toLowerCase() === 'ja') {
        try {
          await client.joinGroupViaLink(joinRequest);
          client.sendText(APPROVAL_GROUP_ID, `Der Bot ist der Gruppe auf Anfrage von @${joinRequests[joinRequest].requester.split('@')[0]} beigetreten.`);
          delete joinRequests[joinRequest];
        } catch (error) {
          client.sendText(APPROVAL_GROUP_ID, `Fehler beim Beitreten der Gruppe: ${error.message}`);
        }
      }
      
      });  
  }

  function sendWaveMessage(client, message, args) {
    const target = args.join(' ');
  
    if (!target) {
      client.sendText(message.from, 'Bitte geben Sie den Namen der Person an, der Sie winken möchten. Beispiel: !wave <Name>');
      return;
    }
  
    client.sendText(message.from, `👋 ${target}, ${message.sender.pushname} winkt dir zu!`);
  }

DEBUG INFO

{
  "WA_VERSION": "2.3000.1014557036",
  "WA_AUTOMATE_VERSION": "4.71.14",
  "BROWSER_VERSION": "HeadlessChrome/112.0.5614.0",
  "START_TS": 1719591479894,
  "RAM_INFO": "Total: 8.49 GB | Free: 1.64 GB",
  "PPTR_VERSION": "19.11.1",
  "LATEST_VERSION": true,
  "CLI": false,
  "PATCH_HASH": "65177",
  "LAUNCH_TIME_MS": 51570,
  "ACC_TYPE": "PERSONAL",
  "chats": 68,
  "messages": 99,
  "contacts": 1436,
  "isBiz": false,
  "isMd": true,
  "INSTANCE_ID": "7d799bb5-76a8-4ecf-8d78-c8a231809b0d"
}

Environment

- OS: Windows 10
- Node: 20.12.2
- npm: 10.5.0

Screenshots/Logs

No response

Anything else?

No
@smashah
Copy link
Member

smashah commented Jun 29, 2024

please restart and try again, should be fixed

@smashah smashah closed this as completed Jun 29, 2024
@moinihosting
Copy link
Author

Same Problem.

@smashah
Copy link
Member

smashah commented Jul 7, 2024

Same Problem.

can you paste the error here please @moinihosting

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
1 participant
@smashah