On a messageReactionAdd event, one of the parameters is a MessageReaction. From that reaction, I do message.reaction to find the message that the reaction is from. I want to use that message to find all the reactions that the parameters user has reacted to on that message.
However, one obstacle is that when the bot restarts, it seems as though the message.reactions is not fully populated, and the data needs to be fetched. I need the users of a looped reaction, but I'm struggling on that part.
I have tried:
await message.reactions.reduce((p, c) => c.fetchUsers(), 0);
// I had thought this would of cached the users of every reaction on the message, but that did not work.
// next
message.reactions.forEach((x, y) => {
x.fetchUsers();
});
// this was also the same train of thought, but still to no avail.
What I mean by that users are not in the message.reaction.users object, I mean this:
// the bot restarts - and a reaction is added
console.log(reaction.users);
// outputs: Collection [Map] {}
// this is supposed to be populated with many users, but it's empty
// however, if I add ANY reaction again, not doing anything else
// it outputs a Collection with many users in it, which is expected
I have no idea how to do this.
Edit: relevant code
// raw.js (the raw event)
const events = {
MESSAGE_REACTION_ADD: 'messageReactionAdd',
};
const Discord = require('discord.js');
module.exports = async (client, event) => {
if (!events.hasOwnProperty(event.t)) return;
const { d: data } = event;
const user = client.users.get(data.user_id);
if (!user) return;
const channel = client.channels.get(data.channel_id);
if (!channel) return;
if (channel.messages.has(data.message_id)) return;
const message = await channel.fetchMessage(data.message_id);
const emojiKey = (data.emoji.id) ? `${data.emoji.name}:${data.emoji.id}` : data.emoji.name;
let reaction = message.reactions.get(emojiKey);
if (!reaction) {
const emoji = new Discord.Emoji(client.guilds.get(data.guild_id), data.emoji);
reaction = new Discord.MessageReaction(message, emoji, 1, data.user_id === client.user.id);
}
client.emit(events[event.t], reaction, user);
};
// messageReactionAdd.js (the messageReactionAdd event)
module.exports = async (client, reaction, user) => {
const message = reaction.message;
if (!message)
return;
//await message.reactions.reduce((p, c) => c.fetchUsers(), 0);
message.reactions.forEach((x,y) => {
x.fetchUsers();
});
reactions = await message.reactions.filter(r => r.users.has(`${user.id}`));
console.log(reactions);
};
This code is what fixed this problem for me.
// raw.js event file
await reaction.message.reactions.forEach(r => {
r.fetchUsers({before: `${reaction.message.author.id}`});
});
// emit the messageReactionAdd event
// messageReactionAdd.js event file
// the message.reactions.users should be populated, which I can use
reactions = await reaction.message.reactions.filter(r => r.users.has(`${reaction.message.author.id}`));
I had used this code in the wrong events which made no logical sense which made the results that I had thought was invalid.
Related
Heyo Axmyo here,
I want to autoban user if they mention over 5 humans, not bots
but the code I tried to use doesn't do anything..
Any help would be appreciated!
client.on("message", message => {
if(message.mentions.members.size > 5) {
message.author.ban();
}
})
You're in the right direction, your if statement is correct.
message.author returns a User.
but .ban() is available only on GuildMember.
So you need to convert the User to a GuildMember. Luckily the message object contains the Guild that it was sent in, so you can do the following:
client.on("message", message => {
if(message.mentions.members.size > 5) {
const user = message.author;
const guildMember = message.guild.member(user);
guildMember.ban();
}
})
Notice that .ban() returns a promise, so it might be a good idea to do the following, if you want to do additional things after the ban:
client.on("message", async message => {
if(message.mentions.members.size > 5) {
const user = message.author;
const guildMember = message.guild.member(user);
await guildMember.ban();
// Do other things...
}
})
Edit
message object has a member property on it, thanks Itamar S
client.on("message", async message => {
if(message.mentions.members.size <= 5) return;
await message.member.ban();
// Do other things...
})
My function named status sending information about products that are stored in Firebase Realtime Database. When user ask my bot for status then Firebase function get data from DB and then send back Telegram message for every of product that the user is assigned. For some users this can take some time even 2 minutes.
When 1st user asks bot for status and bot function run for the first time everything is fine.
BUT when 2nd user ask for status during first call of bot function (when function still running for 1st user) first call run start over and after first call is done finally second call are handled.
When 3rd user calls function when old calls are not finished, everything stacking on and finally everything loops until all calls of function are over. Because bot has almost 2000 active users this above problem runs into "infinite" loop because constantly some of users calls "status" for themselves.
This situation causes that users getting almost infinite numbers of messages.
I'm using JavaScript & Node 12 on Firebase.
const { Telegraf, Markup } = require('telegraf');
const { telegrafThrottler } = require('telegraf-throttler');
const functions = require('firebase-functions');
const admin = require('firebase-admin');
const debug = true;
admin.initializeApp(); // initialize firebase-admin
const bot = new Telegraf(functions.config().telegram_token.key); // initialize Telegraf bot
const throttler = telegrafThrottler(); // Telegraf Throttler
bot.use(throttler);
/**
*
bot.command('some_commands_here', async (ctx) => {
const nothing = 'THIS IS NOT IMPORTANT';
});
bot.command(...) more commands
*/
/** action with infinite loop problem */
bot.action('status', async (ctx) => {
const uid = ctx.update.callback_query.from.id;
let userData = await getUserAccountData(admin, uid); // get some data from firebase realtime db
if (userData !== null) {
let userProducts = await getUserProducts(admin, uid); // get some data from firebase realtime db
if (userProducts !== null) {
// userProducts contain even 200 items for one user
for (const [privateProductId, privateProductData] of Object.entries(userProducts)) {
// some not important logic that create message and keyboard context
// after this bot send informations about every product (can be even 200 messages )
await bot.telegram.sendMessage(uid, `${message}`, {
parse_mode: 'html',
reply_markup: keyboard.reply_markup,
});
}
}
}
// some not important logic if userData / userProducts are null
});
/** Default response for undefinded msg/commands */
bot.on('message', (ctx) => ctx.reply("Use /help if You don't know commands!"));
/** bot catch errors here */
bot.catch((err, ctx) => {
if (debug) {functions.logger.error(`Bot Catched ERROR: ${err}`);}
bot.telegram.sendMessage(123456789, `Bot Catched ERROR: ${err}`);
});
const runtimeOpts = {
timeoutSeconds: 500,
memory: '1GB',
};
exports.bot = functions.region('europe-west3').runWith(runtimeOpts).https.onRequest((req, res) => {
// bot.handleUpdate(req.body, res);
bot.handleUpdate(req.body, res).catch((err) => {
if (debug) {functions.logger.error(err);}
});
});
OK Finally I found cause ^^
I'm missed process.once in my code, because of that function was executed more than one time.
process.once('SIGINT', () => bot.stop('SIGINT'));
process.once('SIGTERM', () => bot.stop('SIGTERM'));
I'm creating Discord bot which gives a specific role when users add a specific emoji reaction on a message.
I want to let users choose only one reaction;
or
if the user choose another one, other reactions of the same user should be removed.
I found code only for two situation:
Remove all emoji reactions on a message.
message.reactions.cache.get('emojiId').remove()
Remove the reaction from the user.
const userReactions = message.reactions.cache.filter(reaction => reaction.users.cache.has(userId));
try {
for (const reaction of userReactions.values()) {
await reaction.users.remove(userId);
}
} catch (error) {
console.error('Failed to remove reactions.');
}
Both of them doesn't suit me because they delete all reactiosn to the message.
A part of my code:
client.on('messageReactionAdd', async (reaction, user) => {
if(reaction.partial) await reaction.fetch()
const { message } = reaction
if (message.id === rulesMessageId) {
const member = message.channel.guild.members.cache.get(user.id)
if (reaction.emoji.id === emojiIds.HEAVEN ) {
for (var i = 0 in guildRoles) {
if (guildRoles[i] != guildRoles.HEAVEN)
member.roles.remove(guildRoles[i])
}
member.roles.add(guildRoles.HEAVEN)
}
I don't know how to use a part of your code in the answer so I have do my own :
client.on("messageReactionAdd", (reaction, Member) => {
if(Member.bot) return;
reaction.message.reactions.cache.map(x=>{
if(x._emoji.name != reaction._emoji.name&&x.users.cache.has(Member.id)) x.users.remove(Member.id)
})
});
I get all reaction in the message and map them to check if the user have react. I also check if the reaction is the same as the one currently reacting to remove only the others.
Hope it will help you even if it's 10 months too late ^^
I would like to make some reaction roles. But for that, I have to cache messages which were sent before the bot started. I tried it with channel.messages.fetch, but that hasn't worked so far.
My current code:
client.on('messageReactionAdd', async(reaction, user) => {
client.channels.cache.get("689034237672030230");
channel.messages.fetch('708428887612194979');
// When we receive a reaction we check if the reaction is partial or not
if (reaction.partial) {
// If the message this reaction belongs to was removed the fetching might result in an API error, which we need to handle
try {
await message.reaction.fetch();
} catch (error) {
console.log('Something went wrong when fetching the message: ', error);
// Return as `reaction.message.author` may be undefined/null
return;
}
}
// Now the message has been cached and is fully available
console.log(`${reaction.message.author}'s message "${reaction.message.id}" gained a reaction!`);
// The reaction is now also fully available and the properties will be reflected accurately:
console.log(`${reaction.count} user(s) have given the same reaction to this message!`);
});
What you have to do is first fetch the guild where the channel is in and then get the channel from the guild (so it returns a GuildChannel). Then fetch messages from there.
Full code would be:
client.on('ready', async () => {
const guild = await client.guilds.fetch('guild-id-here');
const channel = guild.channels.cache.get('channel-id-here');
const message = await channel.messages.fetch('message-id-here');
});
client.on('message', message => {
//rest of your code
});
channel.messages.fetch() is not working because channel is not defined. You need to define the first 2 lines as variables:
const channel = client.channels.cache.get("689034237672030230");
const msg = channel.messages.cache.get('708428887612194979');
So im tryna make a little bot that verifies a particular group of users to access a reserved channel. The bot is supposed to ask a secret code, and when the answer is withing the question, the bot replies to itself and an error message is displayed. How do i fix this code?
I've tried using
if(message.author.bot){return;}
but it doesnt work for some reason welp
this is my code:
client.on('guildMemberAdd', member => {
const channel = member.guild.channels.find(ch => ch.name === 'vaayil');
channel.send("type in the secret code");
client.on('message', message =>{
if(message.author.bot){return;}
if(message.content === `secret`){
channel.send("verified");
}
if(message.content !== `secret`){
channel.send("not verified");
}
});
});
Nesting events like that is generally bad practice.
However, you can avoid doing so, and make your life coding this bot easier. In Discord.js, you can use TextChannel.awaitMessages() to wait for messages that pass a certain filter, and then do something with those messages.
Example:
const secretCode = 'sloths';
client.on('guildMemberAdd', async member => {
const channel = member.guild.channels.find(c => c.name === 'vaayil');
if (!channel) return console.log('Can\'t find channel.');
try {
await channel.send(`What\'s the secret code, ${member}?`);
const filter = m => m.author.id === member.id;
const messages = await channel.awaitMessages(filter, { max: 1 });
const message = messages.first(); // (The only message in the Collection)
if (message.content === secretCode) {
await channel.send('That\'s right!');
// Do something...
} else {
await channel.send('Nice try, but wrong.');
// Do something...
} catch(err) {
console.error(err);
}
});