ajout de commande gestion

commands/gestion/create.js

@@ -0,0 +1,48 @@
+const axios = require('axios');
+
+module.exports = {
+    name: 'create',
+    description: 'Crée un emoji',
+    async execute(message, args, client) {
+        if (!args.length) {
+            return message.channel.send({ content: "Veuillez spécifier un émoji." });
+        }
+
+        for (const rawEmoji of args) {
+            // Si rawEmoji est un identifiant d'emoji Discord valide
+            if (rawEmoji.match(/^\d+$/)) {
+                const emoji = client.emojis.cache.get(rawEmoji);
+                if (!emoji) {
+                    return message.channel.send({ content: "L'argument fourni n'est pas un identifiant d'emoji valide." });
+                }
+
+                const extension = emoji.animated ? ".gif" : ".png";
+                const url = `https://cdn.discordapp.com/emojis/${emoji.id}${extension}`;
+
+                // Download the emoji image
+                try {
+                    console.log('Téléchargement de l\'image de l\'emoji...');
+                    const response = await axios.get(url, { responseType: 'arraybuffer' });
+                    console.log(response.data); // Ajoutez ceci pour vérifier le contenu de response.data
+                    const buffer = Buffer.from(response.data, 'binary');
+
+                    // Create the emoji
+                    message.guild.emojis.create(buffer, emoji.name)
+                        .then(createdEmoji => message.channel.send({ content: `Emoji ${createdEmoji} créé avec succès.` }))
+                        .catch(error => message.channel.send({ content: `Une erreur s'est produite lors de la création de l'emoji : ${error}` }));
+                } catch (error) {
+                    console.error(error);
+                    return message.channel.send({ content: `Une erreur s'est produite lors du téléchargement de l'image de l'emoji : ${error}` });
+                }
+            } else {
+                // Si rawEmoji est un emoji Unicode
+                message.guild.emojis.create(rawEmoji, { reason: 'Création d\'emoji à partir d\'un emoji Unicode' })
+                    .then(createdEmoji => message.channel.send({ content: `Emoji ${createdEmoji} créé avec succès.` }))
+                    .catch(error => {
+                        console.error(`Erreur lors de la création de l'emoji : ${error.message}`);
+                        message.channel.send({ content: `Une erreur s'est produite lors de la création de l'emoji : ${error.message}` });
+                    });
+            }
+        }
+    },
+};

commands/gestion/dm.js

@@ -0,0 +1,25 @@
+module.exports = {
+    name: 'dm',
+    description: 'Envoie un message privé à un utilisateur',
+    async execute(message, args) {
+        // Vérifie si un utilisateur a été mentionné
+        const user = message.mentions.users.first();
+        if (!user) {
+            return message.reply('Veuillez mentionner un utilisateur à qui envoyer un message privé.');
+        }
+
+        // Vérifie si un message a été spécifié
+        const dmMessage = args.slice(1).join(' ');
+        if (!dmMessage) {
+            return message.reply('Veuillez spécifier un message à envoyer.');
+        }
+
+        // Envoie le message privé à l'utilisateur
+        try {
+            await user.send(dmMessage);
+            message.reply(`Message envoyé à ${user.tag} : "${dmMessage}"`);
+        } catch (error) {
+            message.reply(`Impossible d'envoyer un message privé à ${user.tag}.`);
+        }
+    },
+};

commands/gestion/massiverole.js

@@ -0,0 +1,127 @@
+const { EmbedBuilder, ActionRowBuilder, StringSelectMenuBuilder } = require('discord.js');
+
+module.exports = {
+    name: 'massiverole',
+    description: 'Donne un rôle à tous les membres du serveur',
+    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) {
+        }
+    }
+}

commands/gestion/renew.js

@@ -0,0 +1,28 @@
+const { PermissionsBitField} = require("discord.js")
+module.exports = {
+    name: 'renew',
+    description: 'Renew un salon',
+    async execute(message, args, client) {
+        const guild = message.guild;
+        const channel = message.mentions.channels.first() || message.channel;
+        const botMember = guild.members.cache.get(client.user.id);
+        // Check if the bot has the 'MANAGE_CHANNELS' permission
+        if (!botMember.permissions.has(PermissionsBitField.Flags.ManageChannels)) {
+            return message.reply("Je n'ai pas la permission de gére les salon");
+        }
+
+        // Check if the channel is deletable
+        if (channel.deletable) {
+            // Clone the channel
+            const newChannel = await channel.clone();
+
+            // Delete the old channel
+            await channel.delete();
+
+            // Send a message in the new channel
+            newChannel.send(`${message.author}, ce salon a été renouvelé.`);
+        } else {
+            return message.reply("Je ne peux pas supprimer ce salon.");
+        }
+    },
+};

commands/gestion/unmassiverole.js

@@ -0,0 +1,127 @@
+const { EmbedBuilder, ActionRowBuilder, StringSelectMenuBuilder } = require('discord.js');
+
+module.exports = {
+    name: 'unmassiverole',
+    description: 'Retire un rôle à tous les membres du serveur',
+    async execute(message, args, client) {
+        // 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('Retrait de rôle')
+            .addFields(fields);
+
+        // Crée un menu déroulant avec les options
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId('unmassiverole_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 === 'unmassiverole_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('Retrait 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, retirez le rôle
+            if (interaction.values[0] === 'launch') {
+                await removeRole(interaction, role, memberType, message); 
+            }
+        });
+    },
+};
+
+async function removeRole(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 retiré des humains.`);
+        for (const member of members.values()) {
+            if (member && member.id && !member.user?.bot) {
+                try {
+                    await member.roles.remove(role, `Unmassiverole : ${message.author.username}`);
+                    count++;
+                } catch (error) {
+                    console.error(`Échec du retrait du rôle au membre ID: ${member.id}, Erreur: ${error.message}`);
+                }
+            }
+        }
+        await interaction.editReply(`Le rôle ${role} a été retiré de ${count} membres humains du serveur.`);
+    } else if (memberType === 'human_and_bot') {
+        await interaction.reply(`Le rôle ${role} est en train d'être retiré des humains et des bots.`);
+        for (const member of members.values()) {
+            if (member && member.id) {
+                try {
+                    await member.roles.remove(role, `Unmassiverole : ${message.author.username}`);
+                    count++;
+                } catch (error) {
+                    console.error(`Échec du retrait du rôle au membre ID: ${member.id}, Erreur: ${error.message}`);
+                }
+            }
+        }
+        await interaction.editReply(`Le rôle ${role} a été retiré de ${count} membres du serveur.`);
+    } else if (memberType === 'bot') {
+        for (const member of members.values()) {
+            if (member && member.id && member.user?.bot) {
+                try {
+                    await member.roles.remove(role, `Unmassiverole : ${message.author.username}`);
+                    count++;
+                } catch (error) {
+                    console.error(`Échec du retrait du rôle au membre ID: ${member.id}`)
+                }
+                try {
+                    await interaction.editReply(`Le rôle ${role} a été retiré de ${count} bots du serveur.`);
+                } catch (error) {
+                }
+            }
+        }
+    }
+};

commands/ping.js

@@ -1,9 +1,28 @@
-const { MessageEmbed } = require('discord.js');
+const { ButtonStyle, ButtonBuilder, ActionRowBuilder } = require('discord.js');
 
 module.exports = {
   name: 'ping',
   description: 'Command to check the latency of the bot.',
   async execute(message, args, client) {
-    message.channel.send('test');
+		const ping = new ButtonBuilder()
+			.setCustomId('confirm')
+			.setLabel('🔄')
+			.setStyle(ButtonStyle.Primary);
+      
+      const row = new ActionRowBuilder()
+			.addComponents(ping);
+    const sentMessage = await message.reply({
+			content: `La latence est de : ${client.ws.ping}`,
+			components: [row],
+		});
+
+    const filter = i => i.customId === 'confirm' && i.user.id === message.author.id;
+    const collector = sentMessage.createMessageComponentCollector({ filter, time:  15000 })
+    collector.on('collect', async (interaction) => {
+      sentMessage.edit({
+        content: `La latence est de : ${client.ws.ping}`,
+        components: [row],
+      });
+  });
   },
 };

loaders/loadCommands.js

@@ -29,7 +29,7 @@ module.exports = (client) => {
         //const botId = client.user.id;
         //const guildId = message.guild.id;
         //const prefix = botTokens.coins[botId].prefix;
-        const prefix = '!';
+        const prefix = '+';
         if (!message.content.startsWith(prefix) || message.author.bot) return;
     
         const args = message.content.slice(prefix.length).trim().split(/ +/);