gestion/commands/gestion/massiverole.js

const { EmbedBuilder, ActionRowBuilder, StringSelectMenuBuilder } = require('discord.js');

module.exports = {
    name: 'massiverole',
    description: 'Donne un rôle à tous les membres du serveur',
    category: 'gestion',
    async execute(message, args) {
        // Vérifie si un rôle a été mentionné
        const role = message.mentions.roles.first();
        if (!role) {
            return message.reply('Veuillez mentionner un rôle.');
        }
        let startname = '👥 Humain';
        let memberType = 'human';
        let fields = [
            { name: 'Rôle', value: role.toString(), inline: true },
            { name: 'Type de membres', value: startname, inline: true },
        ];
        const embed = new EmbedBuilder()
            .setTitle('Attribution de rôle')
            .addFields(fields);

        // Crée un menu déroulant avec les options
        const selectMenu = new StringSelectMenuBuilder()
            .setCustomId('massiverole_select')
            .setPlaceholder('Sélectionnez le type de membres')
            .addOptions([
                { label: '👥 Humain', value: 'human' },
                { label: '👥🤖 Humain et Bot', value: 'human_and_bot' },
                { label: '🤖 Bot', value: 'bot' },
                { label: '🚀 Lancer', value: 'launch' },
            ]);
        // Crée une action de ligne avec le menu déroulant
        const row = new ActionRowBuilder()
            .addComponents(selectMenu);

            const sentMessage = await message.channel.send({ embeds: [embed], components: [row] });

            // Crée un collecteur d'interactions pour le menu déroulant
            const filter = i => i.customId === 'massiverole_select' && i.user.id === message.author.id;
            const collector = sentMessage.createMessageComponentCollector({ filter, time:  15000 })
            collector.on('collect', async (interaction) => {
                if (interaction.values[0] !== 'launch') {
                    memberType = interaction.values[0];
                    let name2;
                    if (interaction.values[0] === 'human') {
                        name2 = '👥 Humain';
                    }
                    if (interaction.values[0] === 'human_and_bot') {
                        name2 = '👥🤖 Humain et Bot';
                    }
                    if (interaction.values[0] === 'bot') {
                        name2 = '🤖 Bot';
                    }
            
                    // Trouvez l'index du champ 'Type de membres' et mettez à jour sa valeur
                    const memberTypeFieldIndex = fields.findIndex(field => field.name === 'Type de membres');
                    if (memberTypeFieldIndex !== -1) {
                        fields[memberTypeFieldIndex].value = name2;
                    }
                
                    // Recréez l'embed avec les champs mis à jour
                    const updatedEmbed = new EmbedBuilder()
                        .setTitle('Attribution de rôle')
                        .addFields(fields);
                
                    // Mettre à jour l'embed dans le message
                    await interaction.update({ embeds: [updatedEmbed] });
                }
            
                // Si l'option "Lancer" est sélectionnée, attribuez le rôle
                if (interaction.values[0] === 'launch') {
                    await assignRole(interaction, role, memberType, message);
                }
            });

    },
};
async function assignRole(interaction, role, memberType, message) {
    let count =   0;

    // Récupère tous les membres pour s'assurer que le cache est complet
    const members = await interaction.guild.members.fetch();

    if (memberType === 'human') {
        await interaction.reply(`Le rôle ${role} est en train d'être donné aux humains.`);
        for (const member of members.values()) {
            if (member && member.id && !member.user?.bot) {
                try {
                    await member.roles.add(role, `Massiverole : ${message.author.username}`);
                    count++;
                } catch (error) {
                    console.error(`Échec de l'attribution du rôle au membre ID: ${member.id}, Erreur: ${error.message}`);
                }
            }
        }
        await interaction.editReply(`Le rôle ${role} a été attribué à ${count} membres humains du serveur.`);
    } else if (memberType === 'human_and_bot') {
        await interaction.reply(`Le rôle ${role} est en train d'être donné aux humains et aux bots.`);
        for (const member of members.values()) {
            if (member && member.id) {
                try {
                    await member.roles.add(role, `Massiverole : ${message.author.username}`);
                    count++;
                } catch (error) {
                    console.error(`Échec de l'attribution du rôle au membre ID: ${member.id}, Erreur: ${error.message}`);
                }
            }
        }
        await interaction.editReply(`Le rôle ${role} a été attribué à ${count} membres du serveur.`);
    } else if (memberType === 'bot') {
        for (const member of members.values()) {
            console.log(`Traitement du membre bot: ${member.id}`); // Log pour le débogage
            if (member && member.id && member.user?.bot) {
                try {
                    await member.roles.add(role, `Massiverole : ${message.author.username}`);
                    count++;
                } catch (error) {
                    console.error(`Échec de l'attribution du rôle au membre ID: ${member.id}, Erreur: ${error.message}`);
                }
            }
        }
        try {
            await interaction.editReply(`Le rôle ${role} a été attribué à ${count} bots du serveur.`);
        } catch (error) {
        }
    }
}