Merge branch 'main' of https://github.com/Tutur33/gestion

commands/botcontrol/compet.js

@@ -0,0 +1,25 @@
+const { ActivityType } = require("discord.js");
+
+module.exports = {
+  name: 'competion',
+  aliases: ['compet'],
+  description: 'Changer le status du bot en competition',
+  emote: '🎤',
+  utilisation: 'compet <status>',
+  category: 'botcontrol',
+
+  async execute(message, args, client) {
+    const streamText = args.join(' ') || 'Streaming';
+    const streamURL = 'https://www.twitch.tv/valou336_yt';
+
+    client.user.setPresence({
+        activities: [{
+            name: streamText,
+            type: ActivityType.Competing,
+            url: streamURL
+        }]
+    });
+
+    message.channel.send(`Le bot est maintenant en compétition : ${streamText}`);
+  },
+};

commands/botcontrol/invite.js

@@ -1,4 +1,4 @@
-const { PermissionsBitField } = require('discord.js');
+const { PermissionsBitField , ChannelType } = require('discord.js');
 
 module.exports = {
     name: 'invite',
@@ -7,9 +7,7 @@ module.exports = {
     emote: '🔗', 
     utilisation: 'invite [guildId]',
     category: 'botcontrol',
-
     async execute(message, args, client) {
-        // Vérifie si l'ID du serveur a été fourni
         if (!args[0]) {
             return message.reply('Veuillez fournir l\'ID du serveur.');
         }
@@ -17,7 +15,6 @@ module.exports = {
         const guildId = args[0];
         let guild;
 
-        // Tente de trouver le serveur par ID
         try {
             guild = await client.guilds.fetch(guildId);
         } catch (error) {
@@ -25,20 +22,18 @@ module.exports = {
             return message.reply('Je ne peux pas trouver le serveur avec cet ID.');
         }
 
-        // Vérifie si le bot est membre du serveur
         if (!guild) {
             return message.reply('Le bot n\'est pas membre de ce serveur.');
         }
 
         const botMember = guild.members.cache.get(client.user.id);
 
-        // Vérifie si le bot a la permission de créer des invitations
         if (!botMember.permissions.has(PermissionsBitField.Flags.createInvite)) {
             return message.reply('Le bot n\'a pas la permission de créer des invitations sur ce serveur.');
         }
 
         const channel = guild.channels.cache 
-        .filter((channel) => channel.type === 'GUILD_TEXT')
+        .filter((channel) => channel.type === ChannelType.GuildText)
         .first();
         if (!channel) return message.channel.send(`Aucun channel textuel n'a été trouvé dans ce serveur.`);
     

commands/botcontrol/say.js

@@ -14,7 +14,6 @@ module.exports = {
     try {
     await message.delete();
     } catch {
-      console.log('Impossible de supprimer le message de la commande say');
     }
     message.channel.send(text);
   },

commands/game/anime.js

@@ -0,0 +1,50 @@
+const Discord = require("discord.js");
+const malScraper = require('mal-scraper');
+
+module.exports = {
+    name: "anime",
+    description: "Obtenez des informations sur un anime!",
+    emote: '🎬', 
+    category: 'utils', 
+    utilisation: 'anime <anime_name>', 
+  async execute(message, args, client) {
+
+    const search = `${args}`;
+    if (!search)
+      return message.reply(':x: | Veuillez ajouter une requête de recherche.');
+
+    malScraper.getInfoFromName(search)
+      .then((data) => {
+        const malEmbed = new Discord.EmbedBuilder()
+          .setAuthor( {name: `Résultat de recherce pour ${args}`.split(',').join(' ')})
+          .setImage(data.picture)
+          .addFields(
+            { name: '📆 Première', value: `\`${data.premiered}\``, inline: true },
+            { name: '📺 Diffuser', value: `\`${data.broadcast}\``, inline: true },
+            { name: '🎭 Genres', value: `\`${data.genres}\``, inline: true },
+            { name: '🇬🇧 Titre anglais', value: `\`${data.englishTitle}\``, inline: true },
+            { name: '🇯🇵 Titre japonais', value: `\`${data.japaneseTitle}\``, inline: true },
+            { name: '🎬 Type', value: `\`${data.type}\``, inline: true },
+            { name: '📚 Episodes', value: `\`${data.episodes}\``, inline: true },
+            { name: '🌟 Evaluation', value: `\`${data.rating}\``, inline: true },
+            { name: '📡 Diffusé', value: `\`${data.aired}\``, inline: true },
+            { name: '💯 Score', value: `\`${data.score}\``, inline: true },
+            { name: '👍 Favori', value: `\`${data.favorites}\``, inline: true },
+            { name: '📊 Classé', value: `\`${data.ranked}\``, inline: true },
+            { name: '⌛ Durée', value: `\`${data.duration}\``, inline: true },
+            { name: '🎥 Studios', value: `\`${data.studios}\``, inline: true },
+            { name: '📈 Popularité', value: `\`${data.popularity}\``, inline: true },
+            { name: '👥 Membres', value: `\`${data.members}\``, inline: true },
+            { name: '📊 Score Stats', value: `\`${data.scoreStats}\``, inline: true },
+            { name: '🔍 Source', value: `\`${data.source}\``, inline: true },
+            { name: '🔄 Synonymes', value: `\`${data.synonyms}\``, inline: true },
+            { name: '🔁 Status', value: `\`${data.status}\``, inline: true },
+            { name: '🆔 Identifier', value: `\`${data.id}\``, inline: true },
+            { name: '🔗 Link', value: `\`${data.url}\``, inline: true }
+           )
+
+        message.channel.send({embeds: [malEmbed]});
+
+      })
+  }
+};

commands/game/ascii.js

@@ -0,0 +1,29 @@
+const Discord = require('discord.js')
+const db = require('quick.db')
+const figlet = require("figlet")
+
+module.exports = {
+    name: 'ascii',
+    description: "Écrivez vos textes en ASCII",
+    emote: '🎨',
+    category: 'utils', 
+    utilisation: 'ascii <text>',
+    async execute(message, args, client) {
+        if(!args[0]) return message.channel.send(' **Veuillez fournir du texte**');
+
+        msg = args.join(" ");
+
+        message.delete()
+        
+        figlet.text(msg, function (err, data){
+            if(err){
+                console.log(`Quelque chose s'est mal passé`);
+                console.dir(err);
+            }
+            if(data.length > 2000) return message.channel.send('**Veuillez fournir un texte de moins de 2 000 caractères**')
+
+            message.channel.send('```' + data + '```')
+        })
+
+    }
+}  

commands/game/guessThePokemon.js

@@ -24,8 +24,5 @@ module.exports = {
           });
           
           Game.startGame();
-          Game.on('gameOver', result => {
-            console.log(result);  // =>  { result... }
-          });
     },
 };

commands/game/lc.js

@@ -0,0 +1,41 @@
+const Discord = require("discord.js"),
+md5 = require("md5");
+module.exports = {
+    name :"lc",
+    aliases:["lovecalc"],
+    description:"calcul un pourcentage d'amour entre deux membres mentionnés",
+    emote: '💘', 
+    category: "utils", 
+    utilisation: 'lc <@member1> <@member2>',
+    async execute(message, args, client) {
+        const firstMember = message.mentions.members.filter(m => m.id !== message.author.id).first();
+        if (!firstMember)
+        return message.channel.send("veuillez mettre une membre valide");
+        const secondMember =
+        message.mentions.members
+        .filter(m => m.id !== firstMember.id)
+        .filter(m => m.id !== message.author.id)
+        .first() || message.member;
+        if(!secondMember)
+        return message.error("veuillez mettre une membre valide");
+        const members = [firstMember, secondMember].sort(
+                (a, b) => parseInt(a.id, 10) - parseInt(b.id, 10)
+            );
+            const hash = md5(
+                `${members[0].id}${members[1].user.username}${members[0].user.username}${members[1].id}`
+            );
+
+        const string = hash
+        .split("")
+        .filter(e => !isNaN(e))
+        .join("");
+        const percent = parseInt(string.substr(0, 2), 10);
+
+        const embed = new Discord.EmbedBuilder()
+        .setTitle("❤️ LoveCalc")
+        .setDescription(`${firstMember.user.username} et ${secondMember.user.username} s'aime à ${percent}% `)
+          .setImage(firstMember.user.displayAvatarURL({ dynamic: true }) + secondMember.user.displayAvatarURL({ dynamic: true }))
+          .setColor('#C71585')
+          message.channel.send({embeds: [embed]})
+    }
+}

commands/game/marry.js

@@ -0,0 +1,53 @@
+const { ActionRowBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+module.exports = {
+    name: 'marry',
+    description: 'Proposez en mariage à un utilisateur',
+    emote: '💍', 
+    category: 'game', 
+    category: '+marry @user',
+    async execute(message, args, client) {
+        const targetUser = message.mentions.users.first() || message.guild.members.cache.get(args[0]);
+        if (!targetUser) {
+            return message.reply('Veuillez mentionner un utilisateur ou fournir un ID d\'utilisateur.');
+        }
+        const isRequesterMarried = checkIfMarried(message.author.id, client);
+        if (isRequesterMarried === true) {
+            return message.reply('Vous êtes déjà marié.');
+        }
+        const isTargetMarried = checkIfMarried(targetUser.id, client);
+        if (isTargetMarried === true) {
+            return message.reply('Cet utilisateur est déjà marié.');
+        }
+        const row = new ActionRowBuilder()
+            .addComponents(
+                new ButtonBuilder()
+                    .setCustomId(`acceptmarriage_${targetUser.id}_${message.author.id}`)
+                    .setLabel('Accepter')
+                    .setStyle(ButtonStyle.Success),
+            );
+
+        message.channel.send({ content: `${targetUser}`, components: [row] });
+    },
+};
+async function checkIfMarried(userId, client) {
+    let data = await new Promise((resolve, reject) => {
+        db.get('SELECT value FROM gestion WHERE id = ?', [client.user.id], (err, row) => {
+            if (err) {
+                console.error(err.message);
+                reject(err);
+            }
+            const parsedData = row ? JSON.parse(row.value) : {};
+            parsedData.marry = parsedData.marry || [];
+            resolve(parsedData);
+        });
+    });
+
+    const isMarried = data.marry.some(pair => {
+        const [userId1, userId2] = pair.split('_');
+        return userId1 === userId || userId2 === userId;
+    });
+
+    return isMarried;
+}

commands/game/unmarry.js

@@ -0,0 +1,98 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+module.exports = {
+    name: 'unmarry',
+    description: 'Dissoudre un mariage',
+    emote: '💍',
+    category: 'game', 
+    utilisation: '+unmarry',
+    execute(message, args, client) {
+
+        checkIfMarried(message.author.id, client).then(isMarried => {
+            if (!isMarried) {
+                return message.reply('Vous n\'êtes pas marié.');
+            }
+
+            findMarriage(message.author.id, client).then(marriagePair => {
+                if (!marriagePair) {
+                    return message.reply('Une erreur s\'est produite lors de la recherche du mariage.');
+                }
+
+                unregisterMarriage(marriagePair, client).then(() => {
+                    message.reply('Votre mariage a été dissous.');
+                }).catch(err => {
+                    console.error(err);
+                    message.reply('Une erreur s\'est produite lors de la suppression du mariage.');
+                });
+            }).catch(err => {
+                console.error(err);
+                message.reply('Une erreur s\'est produite lors de la recherche du mariage.');
+            });
+        }).catch(err => {
+            console.error(err);
+            message.reply('Une erreur s\'est produite lors de la vérification du mariage.');
+        });
+    },
+};
+
+async function checkIfMarried(userId, client) {
+    let data = await new Promise((resolve, reject) => {
+        db.get('SELECT value FROM gestion WHERE id = ?', [client.user.id], (err, row) => {
+            if (err) {
+                console.error(err.message);
+                reject(err);
+            }
+            const parsedData = row ? JSON.parse(row.value) : {};
+            parsedData.marry = parsedData.marry || [];
+            resolve(parsedData);
+        });
+    });
+
+    const isMarried = data.marry.some(pair => {
+        const [userId1, userId2] = pair.split('_');
+        return userId1 === userId || userId2 === userId;
+    });
+
+    return isMarried;
+}
+async function findMarriage(userId, client) {
+    let data = await new Promise((resolve, reject) => {
+        db.get('SELECT value FROM gestion WHERE id = ?', [client.user.id], (err, row) => {
+            if (err) {
+                console.error(err.message);
+                reject(err);
+            }
+            resolve(row ? JSON.parse(row.value) : {});
+        });
+    });
+
+    const marriagePair = data.marry.find(pair => {
+        const [userId1, userId2] = pair.split('_');
+        return userId1 === userId || userId2 === userId;
+    });
+
+    return marriagePair;
+}
+
+async function unregisterMarriage(marriagePair, client) {
+    let data = await new Promise((resolve, reject) => {
+        db.get('SELECT value FROM gestion WHERE id = ?', [client.user.id], (err, row) => {
+            if (err) {
+                console.error(err.message);
+                reject(err);
+            }
+            resolve(row ? JSON.parse(row.value) : {});
+        });
+    });
+
+    const [userId1, userId2] = marriagePair.split('_');
+    data.marry = data.marry.filter(pair => pair !== marriagePair && pair !== `${userId2}_${userId1}`);
+
+
+    db.run('UPDATE gestion SET value = ? WHERE id = ?', [JSON.stringify(data), client.user.id], function(err) {
+        if (err) {
+            console.error(err.message);
+            throw err;
+        }
+    });
+}

commands/game/zalgo.js

@@ -0,0 +1,21 @@
+const {  EmbedBuilder } = require('discord.js');
+const Zalgo = require('to-zalgo')
+
+module.exports = {
+    name: 'zalgo',
+    aliases: ['zlg'], 
+    description: 'Convertissez vos textes en Zalgo',
+    usage: 'zalgo <text>',
+    async execute(message, args, client) {
+
+        message.channel.send({embeds: [ new EmbedBuilder()
+            .setAuthor({name: message.author.tag})
+            .setTitle(`Votre texte: ${args.join(" ")}`)
+            .setDescription(`${Zalgo(args.join(" "))}`)
+            .setFooter({ text: `${client.user.username}`  })
+            .setTimestamp()]}
+           
+        )
+
+    }
+}

commands/gestion/autoreact.js

@@ -0,0 +1,78 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'autoreact',
+    description: 'Ajoute des réactions automatiques à un salon',
+    usage: '+autoreact <channel ou id de salon> <emojie1> <emoite2> ...',
+    async execute(message, args) {
+        if (args[0] === "remove" || args[0] === "del" ){
+            const channel = message.mentions.channels.first() || message.guild.channels.cache.get(args[0]);
+            if (!channel) {
+                return message.reply('Salon invalide.');
+            }
+            let data = await new Promise((resolve, reject) => {
+                db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], (err, row) => {
+                    if (err) {
+                        console.error(err.message);
+                        reject(err);
+                    }
+                    resolve(row ? JSON.parse(row.value) : {});
+                });
+            });
+            if (!data[message.guild.id]) {
+                data[message.guild.id] = {};
+            }
+            if (!data[message.guild.id].autoreact) {
+                data[message.guild.id].autoreact = {};
+            }
+            delete data[message.guild.id].autoreact[channel.id]
+
+            db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], (err) => {
+                if (err) {
+                    console.error(err.message);
+                    return message.reply('Une erreur s\'est produite lors de la mise à jour de la base de données.');
+                }
+                message.reply(`Les réactions automatiques ont été supprimé pour le salon ${channel.name}.`);
+            });
+        }else {
+        if (args.length < 2) {
+            return message.reply('Veuillez fournir un salon et au moins une émojie.');
+        }
+
+        const channel = message.mentions.channels.first() || message.guild.channels.cache.get(args[0]);
+        if (!channel) {
+            return message.reply('Salon invalide.');
+        }
+
+        const emojis = args.slice(1);
+
+        let data = await new Promise((resolve, reject) => {
+            db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], (err, row) => {
+                if (err) {
+                    console.error(err.message);
+                    reject(err);
+                }
+                resolve(row ? JSON.parse(row.value) : {});
+            });
+        });
+
+        if (!data[message.guild.id]) {
+            data[message.guild.id] = {};
+        }
+
+        if (!data[message.guild.id].autoreact) {
+            data[message.guild.id].autoreact = {};
+        }
+        data[message.guild.id].autoreact[channel.id] = emojis;
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], (err) => {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur s\'est produite lors de la mise à jour de la base de données.');
+            }
+            message.reply(`Les réactions automatiques ont été ajoutées pour le salon ${channel.name}.`);
+        });
+    }
+    },
+};

commands/gestion/clearwbh.js

@@ -0,0 +1,30 @@
+const { PermissionsBitField } = require('discord.js');
+
+module.exports = {
+    name: 'clearwbh',
+    description: 'Supprime tous les webhooks du serveur',
+    emote: '🗑️',
+    utilisation: 'clearwbh',
+    category: 'moderation',
+    async execute(message, args, client) {
+        const botMember = message.guild.members.cache.get(client.user.id);
+        if (!botMember.permissions.has(PermissionsBitField.Flags.ManageWebhooks)) {
+            return message.reply('Le bot n\'a pas la permission de gérer les webhooks.');
+        }
+        const webhooks = await message.guild.fetchWebhooks();
+
+        const initialMessage = await message.reply('Début de la suppression des webhooks...');
+
+        for (const webhook of webhooks.values()) {
+            await webhook.delete('Suppression des webhooks par la commande +clearwbh')
+              .then(() => {
+                 initialMessage.edit(`Webhook ${webhook.name} a été supprimé avec succès. ${webhooks.size - 1} webhooks restants à supprimer.`);
+             })
+             .catch(error => {
+                    initialMessage.edit(`Une erreur s'est produite lors de la suppression du webhook ${webhook.name}. ${webhooks.size - 1} webhooks restants à supprimer.`);
+             });
+        }
+
+        initialMessage.edit('Tous les webhooks ont été supprimés du serveur.');
+    },
+};

commands/gestion/embed.js

@@ -1,4 +1,4 @@
-const { EmbedBuilder, ActionRowBuilder, StringSelectMenuBuilder } = require('discord.js');
+const { EmbedBuilder, ActionRowBuilder, StringSelectMenuBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
 
 module.exports = {
     name: 'embed',
@@ -7,97 +7,170 @@ module.exports = {
     emote: '📝',
     utilisation: 'embed',
     category: 'gestion',
-    
     async execute(message, args, client) {
-        const embed = new EmbedBuilder();
+    
-
+    var selectMenu = new StringSelectMenuBuilder()
-        const menu = new StringSelectMenuBuilder()
+            .setCustomId("embedbuilder")
-            .setCustomId('embed-options')
+            .setPlaceholder("Choisissez une option")
-            .setPlaceholder('Select an option')
             .addOptions([
-                { label: '📝 Titre', value: 'title' },
+                { label: '📝 Modifier le Titre', value: 'embedtitle' },
-                { label: '📖 Description', value: 'description' },
+                { label: '💬 Modifier la Description', value: 'embeddescription'},
-                { label: '🎨 Couleur', value: 'color' },
+                { label: "🕵️‍♂️ Modifier l'Auteur", value: 'embedauthor'},
-                { label: '🖼️ Image URL', value: 'image' },
+                { label: '🔻 Modifier le Footer', value: 'embedfooter'},
-                { label: '🖼️ Thumbnail URL', value: 'thumbnail' },
+                { label: '🔳 Modifier le Thumbnail', value: 'embedthumbnail'},
-                { label: '👤 Autheur', value: 'author' },
+                { label: '🕙 Modifier le Timestamp', value: 'embedtimestamp'},
-                { label: '👣 Footer', value: 'footer' },
+                { label: "🖼 Modifier l'Image", value: 'embedimage'},
-                { label: '🚀 Envoyer', value: 'send' },
+                { label: "🌐 Modifier l'URL", value: 'embedurl'},
+                { label: '🔴 Modifier la Couleur', value: 'embedcolor'},
             ]);
+        var embedBuilderActionRow = new ActionRowBuilder()
+            .addComponents([selectMenu])
+        let embed = (new EmbedBuilder({ description: '\u200B' }))
 
-        const row = new ActionRowBuilder()
+        var actionRow = new ActionRowBuilder()
-            .addComponents(menu);
+        actionRow.addComponents([
+            new ButtonBuilder()
+            .setCustomId("embedsend")
+            .setLabel("Envoyer l'embed")
+            .setStyle(ButtonStyle.Success)
+            .setEmoji("✅")
+        ])
 
-        const selectMenuMessage = await message.channel.send({ content: `Veuillez sélectionner une option pour l'embed:`, components: [row] });
+        let msg = await message.channel.send({ embeds: [embed], components: [embedBuilderActionRow, actionRow]})
-
+        var collector = msg.createMessageComponentCollector({
-        client.on('interactionCreate', async (interaction) => {
+            filter: (interaction) => interaction.user.id === message.author.id,
-            if (!interaction.isSelectMenu()) return;
+            time: 150000 
-
-            if (interaction.customId === 'embed-options') {
-                const selectedOption = interaction.values[0];
-
-                if (selectedOption === 'send') {
-                    const channelMessage = await interaction.reply({ content: `Veuillez mentionner le salon où l'embed sera envoyé.`, fetchReply: true });
-                    const channelFilter = m => m.author.id === interaction.user.id;
-                    const channelCollector = interaction.channel.createMessageCollector({ filter: channelFilter, max: 1, time: 60000 }); // 1 minute to reply
-
-                    channelCollector.on('collect', async (m) => {
-                        let channel = m.mentions.channels.first();
-                        if (!channel) {
-                            const channelId = m.content;
-                            channel = interaction.guild.channels.cache.get(channelId);
-                        }
-
-                        if (!channel) {
-                            interaction.followUp({ content: 'Salon invalide.' });
-                            return;
-                        }
-
-                        channel.send({ embeds: [embed] });
-                        message.channel.send(`Embed correctement envoyé dans le channel <#${channel.id}>`)
-                    });
-                } else {
-                    const optionMessage = await interaction.reply({ content: `Veuillez entrer ${selectedOption} de l'embed:`, fetchReply: true });
-                    const optionFilter = m => m.author.id === interaction.user.id;
-                    const optionCollector = interaction.channel.createMessageCollector({ filter: optionFilter, max: 1 });
-                    optionCollector.on('collect', async (m) => {
-                        let optionValue = '';
-                        if (m.content.toLowerCase() !== 'cancel') {
-                            optionValue = m.content;
-                        }
-
-                        optionMessage.delete();
-                        m.delete();
-
-                        switch (selectedOption) {
-                            case 'title':
-                                embed.setTitle(optionValue);
-                                break;
-                            case 'description':
-                                embed.setDescription(optionValue);
-                                break;
-                            case 'color':
-                                embed.setColor(optionValue);
-                                break;
-                            case 'image':
-                                embed.setImage(optionValue);
-                                break;
-                            case 'thumbnail':
-                                embed.setThumbnail(optionValue);
-                                break;
-                            case 'author':
-                                embed.setAuthor({ name: optionValue });
-                                break;
-                            case 'footer':
-                                embed.setFooter({ name: optionValue });
-                                break;
-                        }
-
-
-                        selectMenuMessage.edit({ embeds: [embed], components: [row] });
-                    });
-                }
-            }
         });
-    },
+        
-};
+    
+        collector.on("collect", async (i) => {
+            i.deferUpdate()
+            if(i.customId == "embedbuilder") {
+                if(i.values[0] == "embedtitle") {
+                    let question = await message.channel.send({ content: "Veuillez saisir le titre de l'embed" })
+                    let collected = await question.channel.awaitMessages({ filter: m => m.author.id === message.author.id, max: 1 }).then(collected => {
+                        let msgg = collected.first()
+                        embed.setTitle(msgg.content)
+                        msg.edit({ embeds: [embed]})
+                    })
+                }
+                if(i.values[0] == "embeddescription") {
+                    let question = await message.channel.send({ content: "Veuillez saisir la description de l'embed" })
+                    let collected = await question.channel.awaitMessages({ filter: m => m.author.id === message.author.id, max: 1 }).then(collected => {
+                        let msgg = collected.first()
+                        embed.setDescription(msgg.content)
+                        msg.edit({ embeds: [embed]})
+                        
+                    })
+                }
+                if(i.values[0] == "embedauthor") {
+                    let question = await message.channel.send({ content: "Veuillez saisir l'auteur de l'embed" })
+                    let collected = await question.channel.awaitMessages({ filter: m => m.author.id === message.author.id, max: 1 }).then(collected => {
+                        let msgg = collected.first()
+                        embed.setAuthor({name: msgg.content})
+                        msg.edit({ embeds: [embed]})
+                    })
+                }
+                if(i.values[0] == "embedfooter") {
+                    let question = await message.channel.send({ content: "Veuillez saisir le footer de l'embed" })
+                    let collected = await question.channel.awaitMessages({ filter: m => m.author.id === message.author.id, max: 1 }).then(collected => {
+                        let msgg = collected.first()
+                        embed.setFooter({text: msgg.content})
+                        msg.edit({ embeds: [embed]})
+                    })
+                }
+                if(i.values[0] == "embedthumbnail") {
+                    var yx = await message.channel.send({ content: "Quel sera le **Thumnail** de l'embed ?" })
+                      let collected = await  message.channel.awaitMessages({ filter: m => m.author.id === message.author.id, max: 1, time: 60000, errors: ["time"] })
+                            .then(async (collected) => {
+                                var a;
+
+                                if (collected.first().attachments.size > 0) {
+                                    collected.first().attachments.forEach(async at => {
+                                        a = at.url
+                                    })
+
+                                } else if (/^https?:\/\/.*\/.*\.(png|gif|webp|jpeg|jpg|svg)\??.*$/gmi.test(collected.first().content) === true) {
+                                    a = collected.first().content
+                                } else {
+                                    a = false
+                                }
+
+                                collected.first().delete().catch(() => false)
+                                yx.delete().catch(() => false)
+
+                                if (a === false) {
+                                    return collected.message.channel.send({ content: "L'image voulue est Invalide." })
+                                } else if (a !== false) {
+                                    embed.setThumbnail(a.toString());
+                                }
+                                msg.edit({ embeds: [embed] })
+                            })
+                }
+                if(i.values[0] == "embedtimestamp") {
+                    embed.setTimestamp(Date.now())
+                    msg.edit({ embeds: [embed]})   
+            }
+            if(i.values[0] == "embedimage") {
+                var yx = await message.channel.send({ content: "Quelle sera l'**Image** de l'embed ?" })
+                let collected = await  message.channel.awaitMessages({ filter: m => m.author.id === message.author.id, max: 1, time: 60000, errors: ["time"] })
+                    .then(async (collected) => {
+                        var a;
+
+                        if (collected.first().attachments.size > 0) {
+                            collected.first().attachments.forEach(async at => {
+                                a = at.url
+                            })
+
+                        } else if (/^https?:\/\/.*\/.*\.(png|gif|webp|jpeg|jpg|svg)\??.*$/gmi.test(collected.first().content) === true) {
+                            a = collected.first().content
+                        } else {
+                            a = false
+                        }
+
+                        collected.first().delete().catch(() => false)
+                        yx.delete().catch(() => false)
+
+                        if (a === false) {
+                            return collected.message.channel.send({ content: "L'image voulue est Invalide." })
+                        } else if (a !== false) {
+                            embed.setImage(a.toString());
+                        }
+                        msg.edit({ embeds: [embed] })
+                        
+                })
+            }
+            if(i.customId == "embedurl") {
+                let question = await message.channel.send({ content: "Veuillez saisir l'URL de l'embed" })
+                let collected = await question.channel.awaitMessages({ filter: m => m.author.id === message.author.id, max: 1 }).then(collected => {
+                    let msgg = collected.first()
+                    embed.setURL(msgg.content)
+                    msg.edit({ embeds: [embed]})
+                        
+                })
+            }
+            if(i.customId == "embedcolor") {
+                let question = await message.channel.send({ content: "Veuillez saisir la couleur de l'embed" })
+                let collected = await question.channel.awaitMessages({ filter: m => m.author.id === message.author.id, max: 1 }).then(collected => {
+                    let msgg = collected.first()
+                    embed.setColor(msgg.content)
+                    msg.edit({ embeds: [embed]})
+                        
+                })
+            }
+            
+        }
+
+        if (i.customId == "embedsend") {
+            let question = await message.channel.send({ content: "Dans quel channel voulez-vous envoyer l'embed?" })
+            let collected = await question.channel.awaitMessages({ filter: m => m.author.id === message.author.id, max: 1 }).then(collected => {
+                let msgg = collected.first()
+                let channel = message.guild.channels.cache.get(msgg.content) || msgg.mentions.channels.first() 
+                channel.send({ embeds: [embed]})
+            })
+        }
+    })
+
+    
+    }
+  }

commands/gestion/giveaway.js

@@ -0,0 +1,62 @@
+const { GiveawaysManager } = require('discord-giveaways');
+const ms = require('ms'); 
+
+module.exports = {
+    name: 'giveaway',
+    utilisation: 'giveaway <durée> <prix> <nombre de gagnants>',
+    description: 'Crée un giveaway avec une durée, un prix et un nombre de gagnants spécifiés.',
+    emote: '🎉',
+    category: 'gestion',
+
+    async execute(message, args, client) {
+        if (args.length < 3) {
+            return message.channel.send('Veuillez fournir une durée, un prix et un nombre de gagnants.');
+        }
+
+        const duration = args[0];
+        const prize = args.slice(1, -1).join(' ');
+        const winnersCount = parseInt(args[args.length - 1]);
+
+        // Vérifie si la durée est valide
+        if (isNaN(ms(duration))) {
+            return message.channel.send('Veuillez fournir une durée valide.');
+        }
+
+        // Vérifie si le nombre de gagnants est valide
+        if (isNaN(winnersCount) || winnersCount < 1) {
+            return message.channel.send('Veuillez fournir un nombre valide de gagnants.');
+        }
+
+        // Crée le giveaway
+        const giveawayChannel = message.channel;
+        const giveawayDuration = ms(duration);
+        const giveawayWinners = winnersCount;
+        client.giveawaysManager.create(giveawayChannel, {
+            duration: giveawayDuration,
+            prize: prize,
+            winnerCount: giveawayWinners,
+            messages: {
+                giveaway: "🎉 **GIVEAWAY** 🎉",
+                giveawayEnded: "🎉 **GIVEAWAY TERMINÉ** 🎉",
+                timeRemaining: "Temps restant : **{duration}**!",
+                inviteToParticipate: "Réagissez avec 🎉 pour participer!",
+                winMessage: "Félicitations, {winners}! Vous avez gagné **{prize}**!",
+                embedFooter: "Giveaway",
+                noWinner: "Giveaway annulé, aucune participation valide.",
+                hostedBy: "Hébergé par: {user}",
+                winners: "gagnant(s)",
+                endedAt: "Se termine le",
+                units: {
+                    seconds: "secondes",
+                    minutes: "minutes",
+                    hours: "heures",
+                    days: "jours",
+                    pluralS: false
+                }
+            }
+        }).then((gData) => {
+            console.log(gData); // Donne des informations sur le giveaway
+        });
+        message.channel.send(`Giveaway créé !`);
+    },
+};

commands/gestion/join.js

@@ -0,0 +1,287 @@
+const { ActionRowBuilder, StringSelectMenuBuilder, EmbedBuilder, ChannelType } = require('discord.js');
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+module.exports = {
+    name: 'join',
+    description: 'Configure le système de join',
+    emote: '🔑',
+    category: 'gestion', 
+    utilisation: 'leave [config/test]',
+    async execute(message, args, client) {
+        const guildId = message.guild.id;
+        const botId = message.client.user.id;
+        const subCommand = args[0];
+        if (subCommand === 'config') {
+        let data = await new Promise((resolve, reject) => {
+            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
+                if (err) {
+                    console.error(err.message);
+
+                    reject(err);
+                }
+                resolve(row ? JSON.parse(row.value) : {});
+            });
+        });
+        data[guildId] = data[guildId] || {};
+        data[guildId].join = data[guildId].join || {};
+        const salonKey = 'salon';
+        const roleKey = 'role';
+        const messageKey = 'message';
+        const dmKey = 'dm';
+        
+        // Création de l'embed
+        const embed = new EmbedBuilder()
+            .setTitle('Configuration du système de join')
+            .addFields(
+                { name: '🔊 Salon', value: `<#${data[guildId].join[salonKey]}>` || '❌', inline: true },
+                { name: '🎭 Rôle', value: `<@&${data[guildId].join[roleKey]}>` || '❌', inline: true },
+                { name: '📝 Message', value: data[guildId].join[messageKey] || '❌', inline: true },
+                { name: '📧 DM', value: data[guildId].join[dmKey] || '❌', inline: true }
+            )     
+            .setColor('#0099ff');
+
+        // Création du select menu
+        const menu = new StringSelectMenuBuilder()
+            .setCustomId(`joinconfig_${guildId}`)
+            .setPlaceholder('Sélectionnez une option')
+            .addOptions([
+                {
+                    label: '🎭 Role',
+                    description: 'Configurer le rôle de join',
+                    value: 'role',
+                },
+                {
+                    label: '🔊 Salon',
+                    description: 'Configurer le salon de join',
+                    value: 'salon',
+                },
+                {
+                    label: '📝 Message',
+                    description: 'Configurer le message de join',
+                    value: 'message',
+                },
+                {
+                    label: '📧 DM',
+                    description: 'Configurer les DM de join',
+                    value: 'dm',
+                },
+                {
+                    label: '🚫 Del dm',
+                    description: 'Supprimer le message de dm',
+                    value: 'nodm',
+                },
+            ]);
+
+        const row = new ActionRowBuilder()
+            .addComponents(menu);
+
+        const sendmessage = await message.channel.send({ embeds: [embed], components: [row] });
+        const filter = i => i.customId.startsWith('joinconfig_') && i.user.id === message.author.id;
+        const filter2 = m => m.author.id === message.author.id;
+        const collector = message.channel.createMessageComponentCollector({ filter:filter, time: 240000 }); 
+
+        collector.on('collect', async i => {
+            const option = i.values[0];
+            if ( option === 'nodm') {
+                let data = await new Promise((resolve, reject) => {
+                    db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
+                        if (err) {
+                            console.error(err.message);
+                            reject(err);
+                        }
+                        resolve(row ? JSON.parse(row.value) : {});
+                    });
+                });
+            
+                if (data[guildId] && data[guildId].join) {
+                    data[guildId].join.dm = null; 
+                }
+                db.run('UPDATE gestion SET value = ? WHERE id = ?', [JSON.stringify(data), botId], function(err) {
+                    if (err) {
+                        console.error(err.message);
+                    }
+                });
+                let data2 = await new Promise((resolve, reject) => {
+                    db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], (err, row) => {
+                        if (err) {
+                            console.error(err.message);
+                            reject(err);
+                        }
+                        resolve(row ? JSON.parse(row.value) : {});
+                    });
+                });
+                const updatedEmbed = new EmbedBuilder()
+                .setColor('#0099ff')
+                .setTitle('Configuration du système de join')
+                .addFields(
+                    { name: '🔊 Salon', value: data2[guildId].join[salonKey] || '❌', inline: true },
+                    { name: '🎭 Rôle', value: data2[guildId].join[roleKey] || '❌', inline: true },
+                    { name: '📝 Message', value: data2[guildId].join[messageKey] || '❌', inline: true },
+                    { name: '📧 DM', value: data2[guildId].join[dmKey] || '❌', inline: true }
+                )
+                .addFields();
+            sendmessage.edit({ embeds: [updatedEmbed], components: [row] });
+            }else {
+                await i.deferReply();
+                const guildId = i.customId.split('_')[1];
+                let promptMessage = '';
+                switch (option) {
+                    case 'commande':
+                        promptMessage = 'Veuillez spécifier la commande de join.';
+                        break;
+                    case 'role':
+                        promptMessage = 'Veuillez spécifier le rôle de join.';
+                        break;
+                    case 'salon':
+                        promptMessage = 'Veuillez spécifier le salon de join.';
+                        break;
+                    case 'message':
+                        promptMessage = 'Veuillez spécifier le message de join.';
+                        break;
+                    case 'dm':
+                        promptMessage = 'Veuillez spécifier les DM de join.';
+                        break;
+                }
+                const question = await i.editReply(promptMessage);
+                const channelCollector = message.channel.createMessageCollector({ filter: filter2, max:  1, time:  60000 });
+                channelCollector.on('collect', async m => {
+                    
+                    let value;
+                    if (option === 'role') {
+                        const match = m.content.match(/<@&(\d+)>/);
+                        if (match) {
+                            const id = match[1]; 
+                            try {
+                                const role = m.guild.roles.cache.get(id);
+                                if (!role) {
+                                    console.log(`Role ID: ${id}`);
+                                    console.log(`Role cache: ${m.guild.roles.cache.map(r => r.id)}`); 
+                                    return message.reply('Le rôle mentionné n\'est pas valide ou n\'existe pas dans ce serveur.');
+                                }
+                                value = id;
+                            } catch(err) {}
+                        } else {
+                            return message.reply('Veuillez spécifier un rôle valide.');
+                        }
+                    } else if (option === 'salon') {
+                        const match = m.content.match(/<#(\d+)>/);
+                        if (match) {
+                            const id = match[1]; 
+                            const channel = m.guild.channels.cache.get(id);
+                            if (!channel || channel.type !== ChannelType.GuildText) {
+                                return message.reply('Le salon mentionné n\'est pas valide ou n\'est pas un salon de texte dans ce serveur.');
+                            }
+                            value = id;
+                        } else {
+                            return message.reply('Veuillez spécifier un salon valide.');
+                        }
+                    } else {
+                        value = m.content;
+                    }
+                    let data = await new Promise((resolve, reject) => {
+                        db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], (err, row) => {
+                            if (err) {
+                                console.error(err.message);
+                                reject(err);
+                            }
+                            resolve(row ? JSON.parse(row.value) : {});
+                        });
+                    });
+    
+
+                    data[guildId] = data[guildId] || {};
+                    data[guildId].join = data[guildId].join || {};
+                    data[guildId].join[option] = value;
+                    db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], (err) => {
+                        if (err) {
+                            return message.reply('Une erreur s\'est produite lors de la mise à jour de la base de données.');
+    
+                        }
+                    });
+
+                    let data2 = await new Promise((resolve, reject) => {
+                        db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], (err, row) => {
+                            if (err) {
+                                console.error(err.message);
+                                reject(err);
+                            }
+                            resolve(row ? JSON.parse(row.value) : {});
+                        });
+                    });
+                    await m.delete();
+                    await question.delete();
+            
+                              const updatedEmbed = new EmbedBuilder()
+                                .setColor('#0099ff')
+                                .setTitle('Configuration du système de join')
+                                .addFields(
+                                    { name: '🔊 Salon', value: `<#${data2[guildId].join[salonKey]}>` || '❌', inline: true },
+                                    { name: '🎭 Rôle', value: `<@&${data2[guildId].join[roleKey]}>` || '❌', inline: true },
+                                    { name: '📝 Message', value: data2[guildId].join[messageKey] || '❌', inline: true },
+                                    { name: '📧 DM', value: data2[guildId].join[dmKey] || '❌', inline: true }
+                                )
+                                .addFields();
+                            sendmessage.edit({ embeds: [updatedEmbed], components: [row] });
+                });
+            }
+        });
+    } else if (subCommand === "test") {
+        function replacePlaceholders(message, member) {
+            return message
+            .replace('{MemberMention}', member.toString())
+            .replace('{MemberName}', member.user.username)
+            .replace('{MemberDisplayName}', member.displayName)
+            .replace('{MemberJoinedAt}', member.joinedAt.toLocaleDateString())
+            .replace('{MemberID}', member.id)
+            .replace('{MemberPic}', member.user.displayAvatarURL({ dynamic: true }))
+            .replace('{MemberCreatedAt}', member.user.createdAt.toLocaleDateString())
+            .replace('{ServerMembersCount}', member.guild.memberCount)
+            .replace('{ServerName}', member.guild.name);
+        }
+        const userid = message.author.id;
+        let data = await new Promise((resolve, reject) => {
+            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
+                if (err) {
+                    console.error(err.message);
+                    reject(err);
+                }
+                resolve(row ? JSON.parse(row.value) : {});
+            });
+        });
+    
+        data = data[guildId]?.join || {};
+    
+        try {
+            if (data.dm) {
+                const dmChannel = await message.author.createDM();
+                const formattedMessage = replacePlaceholders(data.dm, message.member);
+                await dmChannel.send(formattedMessage);
+            }
+        } catch (err) {
+        }
+    
+        try {
+            if (data.salon && data.message) {
+                const channel = message.guild.channels.cache.get(data.salon);
+                if (channel && channel.type === ChannelType.GuildText) {
+                    const formattedMessage = replacePlaceholders(data.message, message.member);
+                    await channel.send(formattedMessage);
+                }
+            }        
+        } catch (err) {
+        }
+    
+        try {
+            if (data.role) {
+                const role = message.guild.roles.cache.get(data.role);
+                if (role) {
+                    await message.member.roles.add(role);
+                    console.log(`Le rôle ${role.name} a été attribué à ${message.member.user.tag}`);
+                }
+            }
+        } catch (err) {
+        }
+        return message.reply("Vous venez de tester le système de join");
+    }
+    },
+};

commands/gestion/leave.js

@@ -0,0 +1,183 @@
+const { ActionRowBuilder, StringSelectMenuBuilder, EmbedBuilder, ChannelType } = require('discord.js');
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+module.exports = {
+    name: 'leave',
+    description: 'Configure le système de leave',
+    emote: '🚪', 
+    category: 'gestion', 
+    utilisation: 'leave [config/test]',
+    async execute(message, args, client) {
+        const guildId = message.guild.id;
+        const botId = message.client.user.id;
+        const subCommand = args[0];
+        if (subCommand === 'config') {
+        let data = await new Promise((resolve, reject) => {
+            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
+                if (err) {
+                    console.error(err.message);
+
+                    reject(err);
+                }
+                resolve(row ? JSON.parse(row.value) : {});
+            });
+        });
+        data[guildId] = data[guildId] || {};
+        data[guildId].leave = data[guildId].leave || {};
+        const salonKey = 'salon';
+        const messageKey = 'message';
+        
+        // Création de l'embed
+        const embed = new EmbedBuilder()
+            .setTitle('Configuration du système de leave')
+            .addFields(
+                { name: '🔊 Salon', value: `<#${data[guildId].leave[salonKey]}>` || '❌', inline: true },
+                { name: '📝 Message', value: data[guildId].leave[messageKey] || '❌', inline: true },
+            )     
+            .setColor('#0099ff');
+
+        // Création du select menu
+        const menu = new StringSelectMenuBuilder()
+            .setCustomId(`leaveconfig_${guildId}`)
+            .setPlaceholder('Sélectionnez une option')
+            .addOptions([
+                {
+                    label: '🔊 Salon',
+                    description: 'Configurer le salon de leave',
+                    value: 'salon',
+                },
+                {
+                    label: '📝 Message',
+                    description: 'Configurer le message de leave',
+                    value: 'message',
+                }
+            ]);
+
+        const row = new ActionRowBuilder()
+            .addComponents(menu);
+
+        const sendmessage = await message.channel.send({ embeds: [embed], components: [row] });
+        const filter = i => i.customId.startsWith('leaveconfig_') && i.user.id === message.author.id;
+        const filter2 = m => m.author.id === message.author.id;
+        const collector = message.channel.createMessageComponentCollector({ filter:filter, time: 240000 }); 
+
+        collector.on('collect', async i => {
+            const option = i.values[0];
+            
+                await i.deferReply();
+                const guildId = i.customId.split('_')[1];
+                let promptMessage = '';
+                switch (option) {
+                    case 'salon':
+                        promptMessage = 'Veuillez spécifier le salon de leave.';
+                        break;
+                    case 'message':
+                        promptMessage = 'Veuillez spécifier le message de leave.';
+                        break;k;
+                }
+                const question = await i.editReply(promptMessage);
+                const channelCollector = message.channel.createMessageCollector({ filter: filter2, max:  1, time:  60000 });
+                channelCollector.on('collect', async m => {
+                    
+                    let value;
+                if (option === 'salon') {
+                        const match = m.content.match(/<#(\d+)>/);
+                        if (match) {
+                            const id = match[1]; 
+                            const channel = m.guild.channels.cache.get(id);
+                            if (!channel || channel.type !== ChannelType.GuildText) {
+                                return message.reply('Le salon mentionné n\'est pas valide ou n\'est pas un salon de texte dans ce serveur.');
+                            }
+                            value = id;
+                        } else {
+                            return message.reply('Veuillez spécifier un salon valide.');
+                        }
+                    } else {
+                        value = m.content;
+                    }
+                    let data = await new Promise((resolve, reject) => {
+                        db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], (err, row) => {
+                            if (err) {
+                                console.error(err.message);
+                                reject(err);
+                            }
+                            resolve(row ? JSON.parse(row.value) : {});
+                        });
+                    });
+    
+
+                    data[guildId] = data[guildId] || {};
+                    data[guildId].leave = data[guildId].leave || {};
+                    data[guildId].leave[option] = value;
+                    db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], (err) => {
+                        if (err) {
+                            return message.reply('Une erreur s\'est produite lors de la mise à jour de la base de données.');
+    
+                        }
+                    });
+
+                    let data2 = await new Promise((resolve, reject) => {
+                        db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], (err, row) => {
+                            if (err) {
+                                console.error(err.message);
+                                reject(err);
+                            }
+                            resolve(row ? JSON.parse(row.value) : {});
+                        });
+                    });
+                    await m.delete();
+                    await question.delete();
+            
+                              const updatedEmbed = new EmbedBuilder()
+                                .setColor('#0099ff')
+                                .setTitle('Configuration du système de leave')
+                                .addFields(
+                                    { name: '🔊 Salon', value: `<#${data2[guildId].leave[salonKey]}>` || '❌', inline: true },
+                                    { name: '📝 Message', value: data2[guildId].leave[messageKey] || '❌', inline: true },
+                                )
+                                .addFields();
+                            sendmessage.edit({ embeds: [updatedEmbed], components: [row] });
+                });
+        });
+    } else if (subCommand === "test") {
+        function replacePlaceholders(message, member) {
+            return message
+            .replace('{MemberMention}', member.toString())
+            .replace('{MemberName}', member.user.username)
+            .replace('{MemberDisplayName}', member.displayName)
+            .replace('{MemberJoinedAt}', member.joinedAt.toLocaleDateString())
+            .replace('{MemberID}', member.id)
+            .replace('{MemberPic}', member.user.displayAvatarURL({ dynamic: true }))
+            .replace('{MemberCreatedAt}', member.user.createdAt.toLocaleDateString())
+            .replace('{ServerMembersCount}', member.guild.memberCount)
+            .replace('{ServerName}', member.guild.name);
+        }
+        const userid = message.author.id;
+        let data = await new Promise((resolve, reject) => {
+            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
+                if (err) {
+                    console.error(err.message);
+                    reject(err);
+                }
+                resolve(row ? JSON.parse(row.value) : {});
+            });
+        });
+    
+        data = data[guildId]?.leave || {};
+    
+        try {
+            if (data.salon && data.message) {
+                const channel = message.guild.channels.cache.get(data.salon);
+                if (channel && channel.type === ChannelType.GuildText) {
+                    const formattedMessage = replacePlaceholders(data.message, message.member);
+                    await channel.send(formattedMessage);
+                }
+            }        
+        } catch (err) {
+        }
+    
+
+        return message.reply("Vous venez de tester le système de leave");
+    }
+    },
+};

commands/gestion/piconly.js

@@ -0,0 +1,50 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+module.exports = {
+    name: "piconly",
+    description: "Permet de mettre le piconly sur un salon",
+    emote: '📸',
+    utilisation: 'piconly [salon/id]',
+    category: 'gestion',
+    async execute(message, args, client) {
+        const channelID = message.mentions.channels.first()?.id || client.channels.cache.get(args[0])?.id;
+        if (!channelID) {
+            return message.reply("veuilez indiquer un salon valide")
+        }
+        const guildId = message.guild.id;
+        const botId = client.user.id;
+        let data = await new Promise((resolve, reject) => {
+            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
+                if (err) {
+                    console.error(err.message);
+                    reject(err);
+                }
+                resolve(row ? JSON.parse(row.value) : {});
+            });
+        });
+        data.piconly = data.piconly || {}; 
+        data.piconly[guildId] = data.piconly[guildId] || {}; 
+        const channeldbid = data.piconly[guildId];
+        if (channelID === channeldbid) {
+            delete data.piconly[guildId]
+            db.run('UPDATE gestion SET value = ? WHERE id = ?', [JSON.stringify(data), botId], function(err) {
+                if (err) {
+                    console.error(err.message);
+                    return message.reply('Une erreur s\'est produite lors de la mise à jour de la base de données.');
+                }
+                message.reply(`Le piconly a etait enléve du salon <#${channelID}>.`);
+            });
+        }else  {
+        data.piconly = data.piconly || {}; 
+        data.piconly[guildId] = data.piconly[guildId] || {}; 
+        data.piconly[guildId] = channelID;
+        db.run('UPDATE gestion SET value = ? WHERE id = ?', [JSON.stringify(data), botId], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur s\'est produite lors de la mise à jour de la base de données.');
+            }
+            message.reply(`Le salon a été marqué pour le piconly est desormais dans la salon <#${channelID}>.`);
+        });
+    }
+    }
+}

commands/logs/logs.js

@@ -26,7 +26,8 @@ module.exports = {
                 { name: '📚 Logs de rôles', value: data[message.guild.id]?.rolelog ? `<#${data[message.guild.id].rolelog}>` : 'Non configuré', inline: true },
                 { name: '🎙️ Logs vocaux', value: data[message.guild.id]?.vocallog ? `<#${data[message.guild.id].vocallog}>` : 'Non configuré', inline: true },
                 { name: '🛡️ Logs de raid', value: data[message.guild.id]?.raidlog ? `<#${data[message.guild.id].raidlog}>` : 'Non configuré', inline: true },
-                { name: '🔧 Logs de modération', value: data[message.guild.id]?.modlog ? `<#${data[message.guild.id].modlog}>` : 'Non configuré', inline: true }
+                { name: '🔧 Logs de modération', value: data[message.guild.id]?.modlog ? `<#${data[message.guild.id].modlog}>` : 'Non configuré', inline: true },
+                { name: '🛡️ raidping', value: data[message.guild.id]?.modlog ? `<#${data[message.guild.id].modlog}>` : 'Non configuré', inline: true },
             );
 
         const selectMenu = new StringSelectMenuBuilder()
@@ -114,10 +115,12 @@ module.exports = {
                             .setColor('#0099ff')
                             .setTitle('Configuration des logs')
                             .addFields(
-                            { name: '📝 Logs de messages', value: data2[guildId]?.messagelog ? `<#${data2[guildId].messagelog}>` : 'Non configuré', inline: true },
+                                { name: '📝 Logs de messages', value: data2[message.guild.id]?.messagelog ? `<#${data2[message.guild.id].messagelog}>` : 'Non configuré', inline: true },
-                            { name: '📚 Logs de rôles', value: data2[guildId]?.rolelog ? `<#${data2[guildId].rolelog}>` : 'Non configuré', inline: true },
+                                { name: '📚 Logs de rôles', value: data2[message.guild.id]?.rolelog ? `<#${data2[message.guild.id].rolelog}>` : 'Non configuré', inline: true },
-                            { name: '🎙️ Logs vocaux', value: data2[guildId]?.vocallog ? `<#${data2[guildId].vocallog}>` : 'Non configuré', inline: true },
+                                { name: '🎙️ Logs vocaux', value: data2[message.guild.id]?.vocallog ? `<#${data2[message.guild.id].vocallog}>` : 'Non configuré', inline: true },
-                            { name: '🛡️ Logs de raid', value: data2[guildId]?.raidlog ? `<#${data2[guildId].raidlog}>` : 'Non configuré', inline: true }
+                                { name: '🛡️ Logs de raid', value: data2[message.guild.id]?.raidlog ? `<#${data2[message.guild.id].raidlog}>` : 'Non configuré', inline: true },
+                                { name: '🔧 Logs de modération', value: data2[message.guild.id]?.modlog ? `<#${data2[message.guild.id].modlog}>` : 'Non configuré', inline: true },
+                                { name: '🛡️ raidping', value: data2[message.guild.id]?.modlog ? `<#${data2[message.guild.id].modlog}>` : 'Non configuré', inline: true },
                              );
                     
                   logmessage.edit({ embeds: [updatedEmbed], components: [row] });

commands/moderation/derank.js

@@ -0,0 +1,43 @@
+const { EmbedBuilder, User } = require("discord.js")
+const { getPermissionLevel } = require('../fonction');
+
+module.exports = {
+    name: 'derank',
+    aliases: ['unrank'],
+    description: 'Remove a role from a member',
+    emote: '🚫',
+    utilisation: 'derank <@member> <role>',
+    category: 'moderation',
+
+  async execute(message, args, client) {
+    const member = message.mentions.members.first();
+    const reason = args.slice(1).join(' ') || 'Aucune raison spécifiée';
+    if (!member) {
+      return message.reply('Veuillez mentionner un membre à kick');
+    }
+    if (member.id === message.author.id) {
+      return message.reply('Vous ne pouvez pas vous kick vous même');
+    }
+    if (member.id === client.user.id) {
+      return message.reply('Vous ne pouvez pas me kick');
+    }
+    if (await getPermissionLevel(member, client) === 11) {
+      return message.reply('Vous ne pouvez pas kick un membre buyer');
+    }
+    if (await getPermissionLevel(member, client) === 10) {
+      return message.reply('Vous ne pouvez pas kick un membre owner');
+    }
+    if (await getPermissionLevel(message.member, client) !== 11 || await getPermissionLevel(message.member, client) !== 10) {
+      if (await getPermissionLevel(member, client) >= await getPermissionLevel(message.member, client)) {
+        return message.reply('Vous ne pouvez pas kick un membre avec une permission égale ou supérieure à la votre');
+      }
+    }
+    
+    try {
+        await member.roles.set([]);
+        message.channel.send(`Tous les rôles ont été supprimés de ${member}.`);
+    } catch (error) {
+        message.reply('Une erreur s\'est produite lors de la suppression des rôles du membre.');
+    }
+  },
+};

commands/moderation/derankall.js

@@ -0,0 +1,30 @@
+module.exports = {
+ name: 'derankall',
+ aliases: ['removeallroles'],
+ description: 'Retire un rôle à tous les membres qui le détiennent',
+ emote: '🚫',
+ utilisation: 'derankall <@role>',
+ category: 'moderation',
+
+ async execute(message, args, client) {
+    const role = message.mentions.roles.first() || message.guild.roles.cache.get(args[0]);;
+    if (!role) {
+      return message.reply('Veuillez mentionner un rôle à retirer');
+    }
+
+    const membersWithRole = message.guild.members.cache.filter(member => member.roles.cache.has(role.id));
+    if (membersWithRole.size === 0) {
+      return message.reply('Aucun membre avec ce rôle n\'a été trouvé');
+    }
+
+    membersWithRole.forEach(async (member) => {
+      try {
+        await member.roles.remove(role);
+      } catch (error) {
+        console.error(`Erreur lors du retrait du rôle ${role.name} à ${member.user.tag}:`, error);
+      }
+    });
+
+    message.channel.send(`Le rôle ${role.name} a été retiré à tous les membres qui le détiennent.`);
+ },
+};

commands/moderation/rlm.js

@@ -0,0 +1,23 @@
+const Discord = require('discord.js');
+
+module.exports = {
+    name: "lrm",
+    aliases: ["rolemembers","rlm"], 
+    description: "Permet de voir les membres d'un rôle",
+    category: 'gestion',
+    emote: '👥',
+    utilisation: 'lrm [nom du rôle]',
+    async execute(message, args, client) {
+       let role = message.mentions.roles.first() || message.guild.roles.cache.get(args[1]) || message.guild.roles.cache.find(r => r.name === args[0]) || message.guild.roles.cache.find(r => r.id === args[0]) || message.guild.roles.cache.find(r => r.name.toLowerCase() === args[0].toLowerCase()) || message.guild.roles.cache.find(r => r.id.toLowerCase() === args[0].toLowerCase())
+       if (!role) return;
+       let members = role.members.map(m=>m.user).join("\n");
+       let count = role.members.size;
+
+       let embed = new Discord.EmbedBuilder()
+       .setTitle(`Liste des membres du ${role.name} `)
+       .setDescription(`${members}`)
+       .setFooter({ text: `Total: ${count}` }); 
+
+       message.channel.send({embeds : [embed]}); 
+    }
+}

commands/moderation/voicekick.js

@@ -0,0 +1,21 @@
+const Discord = require('discord.js');
+
+module.exports = {
+    name: "voicekick",
+    aliases: ["vckick"], 
+    description: "Permet de kick un utilisateur d'un vocal",
+    category: 'moderation',
+    emote: '🔊',
+    utilisation: 'voicekick @user/id]',
+    async execute(message, args, client) {
+        let user = message.guild.members.cache.get(args[0]) || message.mentions.members.first();
+        if (!user) return;
+        if(!user.voice.channel) return message.reply(`${user.user.username} n'est pas dans un salon vocal`)
+        await user.voice.setChannel(null).then(async () => {
+            await message.reply(`${user.user.username} a été kick du salon vocal`)
+        }).catch(async () => {
+            await message.reply(`${user.user.username} n'a pas pu être kick du salon vocal`)
+        })
+
+    }
+}

commands/moderation/voicekickall.js

@@ -0,0 +1,27 @@
+const Discord = require('discord.js');
+
+module.exports = {
+    name: "voicekickall",
+    aliases: ["vckickall"], 
+    description: "Permet de kick tout les membres d'un channel vocal",
+    category: 'moderation',
+    emote: '🔊',
+    utilisation: 'voicekickall [#channel/id] ',
+    async execute(message, args, client) {
+        let channelInput = message.mentions.channels.first() || message.guild.channels.cache.get(args[0])
+        if (!channelInput) return;
+        
+        if (channelInput.type !== Discord.ChannelType.GuildVoice) return message.reply('veuillez mentioner un salon vocal');
+
+        try {
+            channelInput.members.forEach(member => {
+                if (member.voice.channel) {
+                    member.voice.setChannel(null)
+                }
+            })
+            await message.reply(`Le salon vocal ${channelInput} a été vidé.`);
+        } catch (error) {
+            await message.reply('Une erreur s\'est produite lors du déplacement des membres du salon vocal.');
+        }
+    }
+}

commands/moderation/voicemove.js

@@ -0,0 +1,27 @@
+const Discord = require('discord.js');
+
+module.exports = {
+    name: "voicemove",
+    aliases: ["vcmove"], 
+    description: "Permet de move un utilisateur d'un vocal",
+    category: 'moderation',
+    emote: '🔊',
+    utilisation: 'voicemove @user/id #salon/id',
+    async execute(message, args, client) {
+        let user = message.guild.members.cache.get(args[0]) || message.mentions.members.first();
+        let channel = message.guild.channels.cache.get(args[1]) || message.mentions.channels.first() || message.guild.channels.cache.find(c => c.name === args[1]) || message.guild.channels.cache.find(c => c.name.toLowerCase() === args[1].toLowerCase())
+        if (!user) return;
+        if (!channel) return;
+        if (channel.type !== Discord.ChannelType.GuildVoice) return message.reply("le salon");
+        let userVoiceChannel = user.voice.channel;
+        if(!userVoiceChannel) return message.reply(`${user.user.username} n'est pas dans un channel vocal`)
+        
+        await user.voice.setChannel(channel)
+        .then(async () => {
+            await message.reply(`${user.user.username} a été déplacé du channel vocal (${userVoiceChannel}) vers le channel vocal (${channel})`);
+        })
+        .catch(error => {
+            message.reply('Une erreur s\'est produite lors du déplacement de l\'utilisateur.');
+        });
+    }
+}

commands/moderation/voicemoveall.js

@@ -0,0 +1,25 @@
+const Discord = require('discord.js');
+
+module.exports = {
+    name: "voicemoveall",
+    aliases: ["vcmoveall"], 
+    description: "Permet de faire venir tous les membres en vocal du serveur dans un channel",
+    category: 'moderation',
+    emote: '🔊',
+    utilisation: 'voicemoveall [#channel/id]',
+    async execute(message, args, client) {
+        let channelInput = message.mentions.channels.first() || message.guild.channels.cache.get(args[0]) || message.member.voice.channel;
+        if (!channelInput) return message.channel.send(`Vous devez être dans un salon vocal pour utiliser cette commande ou sinon en mentionner un.`)
+        
+    if (channelInput.type !== Discord.ChannelType.GuildVoice) return;
+
+        const channels = message.guild.channels.cache.filter(ch => ch.id !== channelInput.id && ch.type !== Discord.ChannelType.GuildVoice && ch.members.size > 0)
+        for await(const [_, channel] of channels)
+            for await(const [_, member] of channel.members) {
+                await member.voice.setChannel(channelInput, `voicemoveall by ${message.author.tag}`).catch(() => {
+                })
+            }
+
+        message.channel.send(`Tout les membres ont été déplacé vers ${channelInput}`)
+    }
+}

commands/utils/booster.js

@@ -0,0 +1,19 @@
+const {EmbedBuilder} = require('discord.js');
+
+module.exports = {
+    name: 'booster',
+    description: "Permet de voir les boosters du serveur",
+    category: 'utils',
+    emote: '🚀', 
+    utilisation: 'booster',
+    async execute(message, args, client) {
+
+        let boosters = message.guild.members.cache.filter(m => m.premiumSince)?.map(function(m) {return `<@${m.id}> boost depuis : <t:${parseInt(m.premiumSinceTimestamp / 1000)}:f>`}).join("\n");
+        if(!boosters || boosters.length < 1) boosters = "Personne n'est en train de booster le serveur";
+ 
+        let embed = new EmbedBuilder()
+        .setTitle("Boosters")
+        .setDescription(`**Il y a ${message.guild.members.cache.filter(m => m.premiumSince).size} boosters**\n\n${boosters}`)
+        message.channel.send({embeds : [embed]}); 
+    },
+};

commands/utils/gif.js

@@ -3,7 +3,7 @@ const giphy = require("giphy-api")("eW1dIGt8WPveUcxEZgXAFtEmuZ8MTxmy");
 
 module.exports = {
     name: 'gif',
-    usage: 'gif [terme de recherche]',
+    utilisation: 'gif [terme de recherche]',
     description: 'Recherche un gif basé sur le terme de recherche fourni.',
     emote: '🎮',
     category: 'utils',

commands/utils/help.js

@@ -13,6 +13,22 @@ module.exports = {
   async execute(message, args, client) {
     const botId = client.user.id; 
     const guildId = message.guild.id;
+    if (args[0] === 'msg' ) {
+      const embed = new EmbedBuilder()
+      .setTitle("Arguments de messages")
+      .addFields(
+        { name: '{MemberMention}', value: `Mentionne le membre concerné` , inline: true },
+        { name: '{MemberName}', value: `Le nom du membre concerné` , inline: true },
+        { name: '{MemberDisplayName}', value:'Le pseudo de serveur du membre concerné', inline: true },
+        { name: '{MemberJoinedAt}',value: `La date à la quelle le membre concerné a rejoint le serveur`, inline: true },
+        { name: '{MemberID}', value: `L'ID du membre concerné` , inline: true },
+        { name: '{MemberPic}', value:'La photo de profil du membre concerné' , inline: true },
+        { name: '{MemberCreatedAt}', value: 'La date de création du compte du membre concerné ', inline: true },
+        { name: '{ServerName}', value: 'Le nom du serveur concerné', inline: true },
+        { name: '{ServerMembersCount}', value: 'Le nombre total de membres sur le serveur', inline: true }
+    )
+    return message.reply({ embeds: [embed] });   
+    }
     let data = await new Promise((resolve, reject) => {
       db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
           if (err) {

events/antiraid.js/alerteping.js

@@ -6,9 +6,7 @@ module.exports = {
     name: Events.GuildMemberUpdate,
     async execute(oldMember, newMember, client) {
         const guildId = newMember.guild.id
-        console.log("dddddddd")
         if (!oldMember.permissions.has(PermissionsBitField.Flags.Administrator) && newMember.permissions.has(PermissionsBitField.Flags.Administrator)) {
-            console.log('aaaaaa')
 
 
             let data = await new Promise((resolve, reject) => {
@@ -25,7 +23,6 @@ module.exports = {
             }
 
             if (data[newMember.guild.id].alerte === 'on') {
-                console.log("on")
                 const raidlogChannelId = data[newMember.guild.id].raidlog;
                 const raidlogChannel = newMember.guild.channels.cache.get(raidlogChannelId);
                 const raidMessage = data[newMember.guild.id].raidping || 'Aucun message de raid configuré.';

events/auto/autoreact.js

@@ -0,0 +1,27 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+const { Events } = require("discord.js");
+module.exports = {
+    name: Events.MessageCreate,
+    async execute(message) {
+        if (message.author.bot) return;
+        db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], async (err, row) => {
+            if (err) {
+                console.error(err.message);
+                return;
+            }
+
+            const data = row ? JSON.parse(row.value) : {};
+            const guildData = data[message.guild.id];
+
+            if (guildData && guildData.autoreact && guildData.autoreact[message.channel.id]) {
+                const emojis = guildData.autoreact[message.channel.id];
+
+                try {
+                    await Promise.all(emojis.map(emoji => message.react(emoji)));
+                } catch (error) {
+                }
+            }
+        });
+    },
+};

events/client/ready.js

@@ -49,10 +49,20 @@ module.exports = {
           }
         });
       });
-    });
+    });  
     client.snipes = new Map();
+
+
+
+
+
+
+
     console.log(`Le bot ${client.user.tag} est en ligne
 lien d'invite > https://discord.com/oauth2/authorize?client_id=${client.user.id}&scope=bot&permissions=8`);
+
+
+//AntiCrash
     process.on('unhandledRejection', (reason, p) => {
       console.log(' [antiCrash] :: Unhandled Rejection/Catch');
       console.log(reason, p);

events/gestion/buttongestion.js

@@ -105,6 +105,45 @@ module.exports = {
     } else {
         console.error(`Le salon avec l'ID ${channelId} n'a pas été trouvé.`);
     }
+} else if (interaction.customId.startsWith('acceptmarriage_')) {
+    const userId1 = interaction.customId.split('_')[1];
+    const userId2 = interaction.customId.split('_')[2];
+    const userIdFromInteractionStr = String(interaction.user.id);
+    const userId1Str = String(userId1);
+
+
+    if (userIdFromInteractionStr !== userId1Str) {
+        await interaction.reply({ content: "vous n'avez pas la permission d'interagir.", ephemeral: true });
+        return;
+    } 
+    try {
+    await registerMarriage(userId1, userId2, client);
+    }catch(err){
+    console.log(err)
+    }
+
+    await interaction.reply({ content: '💒 Vous êtes maintenant mariés! 💒'});
         }
     },
-};
+};
+async function registerMarriage(userId1, userId2, client) {
+    let data = await new Promise((resolve, reject) => {
+        db2.get('SELECT value FROM gestion WHERE id = ?', [client.user.id], (err, row) => {
+            if (err) {
+                console.error(err.message);
+                reject(err);
+            }
+            resolve(row ? JSON.parse(row.value) : {});
+        });
+    });
+
+    data.marry = data.marry || [];
+    data.marry.push(`${userId1}_${userId2}`);
+    data.marry.push(`${userId2}_${userId1}`);
+
+    db2.run('UPDATE gestion SET value = ? WHERE id = ?', [JSON.stringify(data), client.user.id], function(err) {
+        if (err) {
+
+        }
+    });
+}

events/gestion/joinevent.js

@@ -0,0 +1,66 @@
+const { ChannelType, Events } = require('discord.js');
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: Events.GuildMemberAdd,
+    async execute(member) {
+        const guildId = member.guild.id;
+        const botId = member.client.user.id;
+
+        function replacePlaceholders(message, member) {
+            return message
+                .replace('{MemberMention}', member.toString())
+                .replace('{MemberName}', member.user.username)
+                .replace('{MemberDisplayName}', member.displayName)
+                .replace('{MemberJoinedAt}', member.joinedAt.toLocaleDateString())
+                .replace('{MemberID}', member.id)
+                .replace('{MemberPic}', member.user.displayAvatarURL({ dynamic: true }))
+                .replace('{MemberCreatedAt}', member.user.createdAt.toLocaleDateString())
+                .replace('{ServerMembersCount}', member.guild.memberCount)
+                .replace('{ServerName}', member.guild.name);
+        }
+
+        let data = await new Promise((resolve, reject) => {
+            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
+                if (err) {
+                    console.error(err.message);
+                    reject(err);
+                }
+                resolve(row ? JSON.parse(row.value) : {});
+            });
+        });
+
+        data = data[guildId]?.join || {};
+
+        try {
+            if (data.dm) {
+                const dmChannel = await member.createDM();
+                const formattedMessage = replacePlaceholders(data.dm, member);
+                await dmChannel.send(formattedMessage);
+            }
+        } catch (err) {
+        }
+
+        try {
+            if (data.salon && data.message) {
+                const channel = member.guild.channels.cache.get(data.salon);
+                if (channel && channel.type === ChannelType.GuildText) {
+                    const formattedMessage = replacePlaceholders(data.message, member);
+                    await channel.send(formattedMessage);
+                }
+            }        
+        } catch (err) {
+        }
+
+        try {
+            if (data.role) {
+                const role = member.guild.roles.cache.get(data.role);
+                if (role) {
+                    await member.roles.add(role);
+                }
+            }
+        } catch (err) {
+        }
+    },
+};

events/gestion/leaveevent.js

@@ -0,0 +1,49 @@
+const { ChannelType, Events } = require('discord.js');
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: Events.GuildMemberRemove,
+    async execute(member) {
+        const guildId = member.guild.id;
+        const botId = member.client.user.id;
+
+        function replacePlaceholders(message, member) {
+            return message
+            .replace('{MemberMention}', member.toString())
+            .replace('{MemberName}', member.user.username)
+            .replace('{MemberDisplayName}', member.displayName)
+            .replace('{MemberJoinedAt}', member.joinedAt.toLocaleDateString())
+            .replace('{MemberID}', member.id)
+            .replace('{MemberPic}', member.user.displayAvatarURL({ dynamic: true }))
+            .replace('{MemberCreatedAt}', member.user.createdAt.toLocaleDateString())
+            .replace('{ServerMembersCount}', member.guild.memberCount)
+            .replace('{ServerName}', member.guild.name);
+        }
+
+        let data = await new Promise((resolve, reject) => {
+            db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
+                if (err) {
+                    console.error(err.message);
+                    reject(err);
+                }
+                resolve(row ? JSON.parse(row.value) : {});
+            });
+        });
+
+        data = data[guildId]?.leave || {};
+
+        try {
+            if (data.salon && data.message) {
+                const channel = member.guild.channels.cache.get(data.salon);
+                if (channel && channel.type === ChannelType.GuildText) {
+                    const formattedMessage = replacePlaceholders(data.message, member);
+                    await channel.send(formattedMessage);
+                }
+            }        
+        } catch (err) {
+        }
+
+
+    },
+};

events/gestion/messageCreate.js

@@ -19,6 +19,9 @@ module.exports = {
             });
         });
         const suggestChannelId = data.suggestChannel && data.suggestChannel[guildId];
+        data.piconly = data.piconly || {}; 
+        data.piconly[guildId] = data.piconly[guildId] || {}; 
+        const channelID = data.piconly[guildId];
 
         if (message.channel.id === suggestChannelId && !message.author.bot) {
             await message.delete();
@@ -40,6 +43,11 @@ module.exports = {
             const suggestionMessage = await message.channel.send({ embeds: [embed], components: [row] });
             suggestionMessage.react('👎')
             suggestionMessage.react('👍')
+        } else if (message.channel.id === channelID) {
+            if (message.attachments.size === 0) {
+                message.delete()
+            } 
+
         }
     },
 };

giveaways.json

@@ -0,0 +1 @@
+[]

loaders/loadCommands.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const sqlite3 = require('sqlite3').verbose();
+const {  ChannelType } = require('discord.js');
 
 module.exports = (client) => {
     const loadCommands = (dir) => {
@@ -69,7 +70,7 @@ module.exports = (client) => {
     client.on('messageCreate', async message => {
         const botId = client.user.id;
         const guildId = message.guild.id;
-    
+        if (message.channel.type === ChannelType.DM) return
         let data = await new Promise((resolve, reject) => {
             db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                 if (err) {
@@ -115,7 +116,7 @@ module.exports = (client) => {
             return;
         }
         if (command) {
-            const permissionLevel = await getPermissionLevel(message.member, client, guildId);
+            const permissionLevel = await getPermissionLevel(message.member, client);
     
             try {
                 if (permissionLevel ===  11) {
@@ -125,8 +126,8 @@ module.exports = (client) => {
                 } else {
                     return message.reply("Vous n'avez pas accès à cette commande.");
                 }
-            } catch {
+            } catch(err) {
-                console.error(`Erreur lors de l'exécution de la commande: ${command.name}`);
+                console.error(`Erreur lors de l'exécution de la commande: ${command.name} , ${err}`);
                 message.reply('Une erreur est survenue lors de l\'exécution de cette commande.');
             }
         }

main.js

@@ -3,10 +3,20 @@ const { Client, IntentsBitField, Collection } = require("discord.js");
 const loadCommands = require("./loaders/loadCommands");
 const loadEvents = require("./loaders/loadEvents");
 const client = new Client({intents: new IntentsBitField(3276799)});
+const { GiveawaysManager } = require('discord-giveaways');
 
 client.events = new Collection();
 client.commands = new Collection();
-
+client.giveawaysManager = new GiveawaysManager(client, {
+  storage: './giveaways.json',
+  updateCountdownEvery: 5000,
+  default: {
+      botsCanWin: false,
+      exemptPermissions: [],
+      embedColor: '#FF0000',
+      reaction: '🎉'
+  }
+});
 (async () => {
   loadCommands(client);
   loadEvents(client);

package.json

@@ -17,17 +17,24 @@
   },
   "homepage": "https://github.com/Tutur33/gestion#readme",
   "dependencies": {
+    "@m3rcena/weky": "^4.3.1",
     "axios": "^1.6.7",
     "color-name-list": "^10.19.0",
     "discord-gamecord": "^4.4.1",
+    "discord-giveaway": "^1.1.5",
+    "discord-giveaways": "^6.0.1",
     "discord.js": "^14.14.1",
     "discordjs-button-pagination": "^3.0.1",
     "dotenv": "^16.4.4",
+    "figlet": "^1.7.0",
     "giphy-api": "^2.0.2",
+    "mal-scraper": "^2.13.1",
+    "md5": "^2.3.0",
     "ms": "^2.1.3",
     "quick.db": "^7.1.3",
     "sqlite": "^5.1.1",
     "sqlite3": "^5.1.7",
+    "to-zalgo": "^1.0.1",
     "weather": "^1.0.4"
   }
 }