grand commit que tutur attend ( marche pas le raidmode en dev)

sinon il y a pleins de truc comme les anti raid , des coorectif ect

README.md

@@ -20,4 +20,4 @@ valou336 - Développeur principal
 
 ## Licence
 
-Ce projet est sous licence Apache 2.0. Consultez le fichier LICENSE pour plus de détails.
+Ce projet est sous licence Privée. Consultez le fichier LICENSE pour plus de détails.

commands/antiraid/antiadmin.js

@@ -0,0 +1,60 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antiadmin',
+    description: 'Gère la protection contre les actions d\'administrateur dans le serveur.',
+    utilisation: 'antiadmin <type> <action>',
+    category: 'antiraid',
+    emote: '🛡️',
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        let type = args[0];
+        let action = args[1];
+
+        if (!type || !action ||
+            (type !== 'whitelist' && type !== 'wl' && type !== 'owner' && type !== 'buyer' && type !== 'off') ||
+            (action !== 'derank' && action !== 'kick' && action !== 'ban' && action !== 'nothing' && action !== 'rien')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antiadmin whitelist/owner/buyer/off derank/kick/ban/nothing`.');
+        }
+        if (type === 'wl') {
+            type = 'whitelist';
+        }
+        if (action === 'rien') {
+            action = 'nothing';
+        }
+
+        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] = {};
+        }
+
+        if (type === 'off') {
+            data[guildId].antiadmin = null;
+            message.reply(`La protection contre les actions d'administrateur a été désactivée.`);
+        } else {
+            data[guildId].antiadmin = {
+                type: type,
+                action: action
+            };
+            message.reply(`La protection contre les actions d'administrateur a été configurée pour les ${type} avec l'action ${action}.`);
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+        });
+    },
+};

commands/antiraid/antiban.js

@@ -0,0 +1,63 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antiban',
+    description: 'Gère la protection contre les bans dans le serveur.',
+    utilisation: 'antiban <type> <action> <nombre>',
+    category: 'antiraid',
+    emote: '⛔', 
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        let type = args[0];
+        let action = args[1];
+        const args2 = args[2]; 
+
+        if (!type || !action || !args2 ||
+            (type !== 'whitelist' && type !== 'wl' && type !== 'owner' && type !== 'buyer' && type !== 'off') ||
+            (action !== 'derank' && action !== 'kick' && action !== 'ban' && action !== 'nothing' && action !== 'rien') ||
+            isNaN(args2)) { 
+            return message.reply('Veuillez utiliser la commande correctement: `+antiban whitelist/owner/buyer/off derank/kick/ban/nothing <nombre>`.');
+        }
+        if (type === 'wl') {
+            type = 'whitelist';
+        }
+        if (action === 'rien') {
+            action = 'nothing';
+        }
+
+        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] = {};
+        }
+
+        if (type === 'off') {
+            data[guildId].antiban = null;
+            message.reply(`La protection contre les bans a été désactivée.`);
+        } else {
+            data[guildId].antiban = {
+                type: type,
+                action: action,
+                number: args2 
+            };
+            message.reply(`La protection contre les bans a été configurée pour les ${type} avec l'action ${action} et le max de ${args2}.`);
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+        });
+    },
+};

commands/antiraid/antibot.js

@@ -0,0 +1,61 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antibot',
+    description: 'Gère la protection contre les bots dans le serveur.',
+    utilisation: 'antibot <type> <action>',
+    category: 'antiraid',
+    emote: '🤖',
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        let type = args[0];
+        let action = args[1];
+
+        if (!type || !action ||
+            (type !== 'whitelist' && type !== 'wl' && type !== 'owner' && type !== 'buyer' && type !== 'off') ||
+            (action !== 'derank' && action !== 'kick' && action !== 'ban' && action !== 'nothing' && action !== 'rien')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antibot whitelist/owner/buyer/off derank/kick/ban/nothing`.');
+        }
+
+        if (type === 'wl') {
+            type = 'whitelist';
+        }
+        if (action === 'rien') {
+            action = 'nothing';
+        }
+
+        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] = {};
+        }
+
+        if (type === 'off') {
+            data[guildId].antibot = null;
+            message.reply(`La protection contre les bots a été désactivée.`);
+        } else {
+            data[guildId].antibot = {
+                type: type,
+                action: action
+            };
+            message.reply(`La protection contre les bots a été configurée pour les ${type} avec l'action ${action}.`);
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+        });
+    },
+};

commands/antiraid/antichannel.js

@@ -0,0 +1,61 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antichannel',
+    description: 'Gère la protection contre les channel dans le serveur.',
+    utilisation: 'antichannel <type> <action>',
+    category: 'antiraid',
+    emote: '#️⃣', 
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        let type = args[0];
+        let action = args[1];
+
+        if (!type || !action ||
+            (type !== 'whitelist' && type !== 'wl' && type !== 'owner' && type !== 'buyer' && type !== 'off') ||
+            (action !== 'derank' && action !== 'kick' && action !== 'ban' && action !== 'nothing' && action !== 'rien')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antichannel whitelist/owner/buyer/off derank/kick/ban/nothing`.');
+        }
+        if (type === 'wl') {
+            type = 'whitelist';
+        }
+        if (action === 'rien') {
+            action = 'nothing';
+        }
+
+        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] = {};
+        }
+
+
+        if (type === 'off') {
+            data[guildId].antichannel = null;
+            message.reply(`La protection contre les channel a été désactivée.`);
+        } else {
+            data[guildId].antichannel = {
+                type: type,
+                action: action
+            };
+            message.reply(`La protection contre les channel a été configurée pour les ${type} avec l'action ${action}.`);
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+        });
+    },
+};

commands/antiraid/antieveryone.js

@@ -4,9 +4,9 @@ const db = new sqlite3.Database('myDatabase.db');
 module.exports = {
     name: 'antieveryone',
     description: 'Active ou désactive la protection contre les mentions de tout le monde dans le serveur.',
-    utilisation: '+antieveryone on/off',
+    utilisation: 'antieveryone on/off',
     category: 'antiraid',
-
+    emote: '📢',
     async execute(message, args, client) {
         const botId = client.user.id;
         const guildId = message.guild.id;

commands/antiraid/antijoin.js

@@ -0,0 +1,45 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antijoin',
+    description: 'Active ou désactive la protection contre les nouveaux membres rejoignant le serveur.',
+    utilisation: 'antijoin on/off',
+    category: 'antiraid',
+    emote: '🚪', 
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        const status = args[0];
+
+        if (!status || (status !== 'on' && status !== 'off')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antijoin on/off`.');
+        }
+
+        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] = {};
+        }
+
+        data[guildId].antijoin = {
+            status: status
+        };
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+            message.reply(`La protection contre les nouveaux membres a été ${status === 'on' ? 'activée' : 'désactivée'}.`);
+        });
+    },
+};

commands/antiraid/antileak.js

@@ -0,0 +1,45 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antileak',
+    description: 'Active ou désactive la protection contre les fuites de données dans le serveur.',
+    utilisation: 'antileak on/off',
+    category: 'antiraid',
+    emote: '🔒',
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        const status = args[0];
+
+        if (!status || (status !== 'on' && status !== 'off' && status !== 'max')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antileak on/off`.');
+        }
+
+        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] = {};
+        }
+
+        data[guildId].antileak = {
+            status: status
+        };
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+            message.reply(`La protection contre les fuites de données a été ${status === 'on' ? 'activée' : status === 'max' ? 'maximisée' : 'désactivée'}.`);
+        });
+    },
+};

commands/antiraid/antilink.js

@@ -4,9 +4,9 @@ const db = new sqlite3.Database('myDatabase.db');
 module.exports = {
     name: 'antilink',
     description: 'Active ou désactive la protection contre les liens dans le serveur.',
-    utilisation: '+antilink on/off all/invite',
+    utilisation: 'antilink on/off all/invite',
     category: 'antiraid',
-
+    emote: '🔗',
     async execute(message, args, client) {
         const botId = client.user.id;
         const guildId = message.guild.id;

commands/antiraid/antimention.js

@@ -0,0 +1,58 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antimention',
+    description: 'Gère la protection contre les mentions dans le serveur.',
+    utilisation: 'antimention <type> <nombre>',
+    category: 'antiraid',
+    emote: '✋',
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        let type = args[0];
+        const nombre = args[1];
+
+        if (!type || !nombre ||
+            (type !== 'whitelist' && type !== 'wl' && type !== 'owner' && type !== 'buyer' && type !== 'off')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antimention whitelist/owner/buyer/off <nombre>`.');
+        }
+        if (type === 'wl') {
+            type = 'whitelist';
+        }
+        if (isNaN(nombre)) {
+            return message.reply('Le nombre fourni n\'est pas valide. Veuillez fournir un nombre.');
+        }
+        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] = {};
+        }
+
+        if (type === 'off') {
+            data[guildId].antimention = null;
+            message.reply(`La protection contre les mentions a été désactivée.`);
+        } else {
+            data[guildId].antimention = {
+                type: type,
+                nombre: nombre 
+            };
+            message.reply(`La protection contre les mentions a été configurée pour les ${type} avec un nombre de ${nombre}.`);
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+        });
+    },
+};

commands/antiraid/antirole.js

@@ -0,0 +1,60 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antirole',
+    description: 'Gère la protection contre les rôles dans le serveur.',
+    utilisation: 'antirole <type> <action>',
+    category: 'antiraid',
+    emote: '👑',
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        let type = args[0];
+        let action = args[1];
+
+        if (!type || !action ||
+            (type !== 'whitelist' && type !== 'wl' && type !== 'owner' && type !== 'buyer' && type !== 'off') ||
+            (action !== 'derank' && action !== 'kick' && action !== 'ban' && action !== 'nothing' && action !== 'rien')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antirole whitelist/owner/buyer/off derank/kick/ban/nothing`.');
+        }
+        if (type === 'wl') {
+            type = 'whitelist';
+        }
+        if (action === 'rien') {
+            action = 'nothing';
+        }
+
+        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] = {};
+        }
+
+        if (type === 'off') {
+            data[guildId].antirole = null;
+            message.reply(`La protection contre les rôles a été désactivée.`);
+        } else {
+            data[guildId].antirole = {
+                type: type,
+                action: action
+            };
+            message.reply(`La protection contre les rôles a été configurée pour les ${type} avec l'action ${action}.`);
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+        });
+    },
+};

commands/antiraid/antithread.js

@@ -0,0 +1,60 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antithread',
+    description: 'Gère la protection contre les threads dans le serveur.',
+    utilisation: 'antiThread <type> <action>',
+    category: 'antiraid',
+    emote: '#️⃣', 
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        let type = args[0];
+        let action = args[1];
+
+        if (!type || !action ||
+            (type !== 'whitelist' && type !== 'wl' && type !== 'owner' && type !== 'buyer' && type !== 'off') ||
+            (action !== 'derank' && action !== 'kick' && action !== 'ban' && action !== 'nothing' && action !== 'rien')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antiThread whitelist/owner/buyer/off derank/kick/ban/nothing`.');
+        }
+        if (type === 'wl') {
+            type = 'whitelist';
+        }
+        if (action === 'rien') {
+            action = 'nothing';
+        }
+
+        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] = {};
+        }
+
+        if (type === 'off') {
+            data[guildId].antiThread = null;
+            message.reply(`La protection contre les threads a été désactivée.`);
+        } else {
+            data[guildId].antiThread = {
+                type: type,
+                action: action
+            };
+            message.reply(`La protection contre les threads a été configurée pour les ${type} avec l'action ${action}.`);
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+        });
+    },
+};

commands/antiraid/antiupdate.js

@@ -0,0 +1,60 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antiupdate',
+    description: 'Gère la protection contre les mises à jour de canal dans le serveur.',
+    utilisation: 'antiupdate <type> <action>',
+    category: 'antiraid',
+    emote: '🔄',
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        let type = args[0];
+        let action = args[1];
+
+        if (!type || !action ||
+            (type !== 'whitelist' && type !== 'wl' && type !== 'owner' && type !== 'buyer' && type !== 'off') ||
+            (action !== 'derank' && action !== 'kick' && action !== 'ban' && action !== 'nothing' && action !== 'rien')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antiupdate whitelist/owner/buyer/off derank/kick/ban/nothing`.');
+        }
+        if (type === 'wl') {
+            type = 'whitelist';
+        }
+        if (action === 'rien') {
+            action = 'nothing';
+        }
+
+        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] = {};
+        }
+
+        if (type === 'off') {
+            data[guildId].antiupdate = null;
+            message.reply(`La protection contre les mises à jour du serveur a été désactivée.`);
+        } else {
+            data[guildId].antiupdate = {
+                type: type,
+                action: action
+            };
+            message.reply(`La protection contre les mises à jour du serveur a été configurée pour les ${type} avec l'action ${action}.`);
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+        });
+    },
+};

commands/antiraid/antiwebhook.js

@@ -0,0 +1,60 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'antiwebhook',
+    description: 'Gère la protection contre les webhooks dans le serveur.',
+    utilisation: 'antiwebhook <type> <action>',
+    category: 'antiraid',
+    emote: '🌐', 
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        let type = args[0];
+        let action = args[1];
+
+        if (!type || !action ||
+            (type !== 'whitelist' && type !== 'wl' && type !== 'owner' && type !== 'buyer' && type !== 'off') ||
+            (action !== 'derank' && action !== 'kick' && action !== 'ban' && action !== 'nothing' && action !== 'rien')) {
+            return message.reply('Veuillez utiliser la commande correctement: `+antiwebhook whitelist/owner/buyer/off derank/kick/ban/nothing`.');
+        }
+        if (type === 'wl') {
+            type = 'whitelist';
+        }
+        if (action === 'rien') {
+            action = 'nothing';
+        }
+
+        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] = {};
+        }
+
+        if (type === 'off') {
+            data[guildId].antiwebhook = null;
+            message.reply(`La protection contre les webhooks a été désactivée.`);
+        } else {
+            data[guildId].antiwebhook = {
+                type: type,
+                action: action
+            };
+            message.reply(`La protection contre les webhooks a été configurée pour les ${type} avec l'action ${action}.`);
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+        });
+    },
+};

commands/antiraid/bunker.js

@@ -20,6 +20,19 @@ module.exports = {
             PermissionsBitField.Flags.ManageEvents,
             PermissionsBitField.Flags.ManageThreads,
             ];
+        if(args[0] === 'bot') {
+            await Promise.all(guild.members.cache.filter(member => member.user.bot).map(member => member.kick()));
+            return message.reply("Tous les bots ont bien été supprimés du serveur");
+        }else if (args[0] === 'role') {
+            await Promise.all(guild.roles.cache.filter(role => dangerousPermissions.some(permission => role.permissions.has(permission))).map(role => role.delete()));
+            return message.reply("Tous les rôles dangereux ont bien été supprimés du serveur");
+        }else if (args[0] === 'salon' || args[0] === 'channels') {
+            await Promise.all(guild.channels.cache.map(async (channel) => {
+                const permissionOverwrites = channel.permissionOverwrites.cache.filter(overwrite => dangerousPermissions.some(permission => overwrite.allow.has(permission) || overwrite.deny.has(permission)));
+                await Promise.all(permissionOverwrites.map(overwrite => channel.permissionOverwrites.edit(overwrite.id, {})));
+            }));
+            return message.reply("Toutes les permissions dangereuses sur les salons ont bien été supprimées du serveur");
+        }else { 
 
         // Kick all bots
         await Promise.all(guild.members.cache.filter(member => member.user.bot).map(member => member.kick()));
@@ -34,5 +47,6 @@ module.exports = {
         }));
 
         await message.reply('Le serveur a bien été sécurisé');
+    }
     },
 };

commands/antiraid/creationlimit.js

@@ -0,0 +1,47 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'creationlimit',
+    description: 'Définit une limite de création de salon après un certain nombre de jours.',
+    utilisation: 'creationlimit off/10d',
+    category: 'antiraid',
+    emote: '🔗',
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.id;
+        const limit = args[0];
+
+        if (!limit || (limit !== 'off' && !limit.match(/^\d+(m|h|d|w)$/))) {
+            return message.reply('Veuillez utiliser la commande correctement: `+creationlimit off/temps`.');
+        }
+
+        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] = {};
+        }
+
+        if (limit === 'off') {
+            data[guildId].creationLimit = null; 
+        } else { 
+            data[guildId].creationLimit = limit; 
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], function(err) {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur est survenue lors de la mise à jour de la configuration.');
+            }
+            message.reply(`La limite de création de compte a été ${limit === 'off' ? 'désactivée' : `fixée à ${limit}`}.`);
+        });
+    },
+};

commands/antiraid/dperm.js

@@ -0,0 +1,98 @@
+const { PermissionsBitField } = require('discord.js');
+
+module.exports = {
+    name: 'dperm',
+    description: 'Supprime une permission spécifiée de tous les rôles qui l\'ont',
+    async execute(message, args) {
+        if (!args[0]) {
+            return message.reply('Veuillez spécifier une permission à supprimer.');
+        }
+        switch (args[0].toLowerCase()) {
+            case 'ban':
+                const permissionToRemove = PermissionsBitField.Flags.BanMembers;
+                if (!permissionToRemove) {
+                    return message.reply('Permission invalide.');
+                }
+        
+                for (const role of message.guild.roles.cache.values()) {
+                    console.log(role.name + '; ' + permissionToRemove + ' ;' + role.permissions);
+                    if (role.permissions.has(permissionToRemove)) {
+                        console.log(`Attempting to remove ban permission from role: ${role.name}`);
+                        try {
+                            await role.permissions.remove(PermissionsBitField.Flags.BanMembers);
+                            console.log(`Successfully removed ban permission from role: ${role.name}`);
+                        } catch (error) {
+                            console.log(`Failed to remove ban permission from role: ${role.name}. Error: ${error}`);
+                        }
+                    }
+                }
+        
+                message.reply(`La permission ${args[0]} a été supprimée de tous les rôles qui l'avaient.`);
+
+                break;
+            case 'webhook':
+                let permissionToRemove1 = PermissionsBitField.Flags.ManageWebhooks
+                if (!permissionToRemove1) {
+                    return message.reply('Permission invalide.');
+                }
+        
+                message.guild.roles.cache.forEach(role => {
+                    if (role.permissions.has(permissionToRemove1)) {
+                        role.permissions.remove(permissionToRemove1)
+                            .then(updatedRole => {
+                                console.log(`Permission ${args[0]} supprimée du rôle ${updatedRole.name}`);
+                            })
+                            .catch(error => {
+                                console.error(`Erreur lors de la suppression de la permission ${args[0]} du rôle ${role.name}: ${error}`);
+                            });
+                    }
+                });
+        
+                message.reply(`La permission ${args[0]} a été supprimée de tous les rôles qui l'avaient.`);
+                break;
+            case 'role':
+                let permissionToRemove2 = PermissionsBitField.Flags.ManageRoles
+                if (!permissionToRemove2) {
+                    return message.reply('Permission invalide.');
+                }
+        
+                message.guild.roles.cache.forEach(role => {
+                    if (role.permissions.has(permissionToRemove2)) {
+                        role.permissions.remove(permissionToRemove2)
+                            .then(updatedRole => {
+                                console.log(`Permission ${args[0]} supprimée du rôle ${updatedRole.name}`);
+                            })
+                            .catch(error => {
+                                console.error(`Erreur lors de la suppression de la permission ${args[0]} du rôle ${role.name}: ${error}`);
+                            });
+                    }
+                });
+        
+                message.reply(`La permission ${args[0]} a été supprimée de tous les rôles qui l'avaient.`);
+                break;
+            case 'servers' || 'serveur':
+                let permissionToRemove3 = PermissionsBitField.Flags.ManageGuild
+                if (!permissionToRemove3) {
+                    return message.reply('Permission invalide.');
+                }
+        
+                message.guild.roles.cache.forEach(role => {
+                    if (role.permissions.has(permissionToRemove3)) {
+                        role.permissions.remove(permissionToRemove3)
+                            .then(updatedRole => {
+                                console.log(`Permission ${args[0]} supprimée du rôle ${updatedRole.name}`);
+                            })
+                            .catch(error => {
+                                console.error(`Erreur lors de la suppression de la permission ${args[0]} du rôle ${role.name}: ${error}`);
+                            });
+                    }
+                });
+        
+                message.reply(`La permission ${args[0]} a été supprimée de tous les rôles qui l'avaient.`);
+                break;
+            default:
+                return message.reply('Permission invalide.');
+        }
+
+    },
+};

commands/antiraid/raidmode.js

@@ -0,0 +1,39 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'raidmode',
+    description: 'Active ou désactive le mode raid pour supprimer une permission spécifiée de tous les rôles qui l\'ont',
+    async execute(message, args) {
+        const botId = message.client.user.id;
+        const guildId = message.guild.id;
+        const guild = message.guild
+        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) : {});
+            });
+        });
+
+        const isRaidModeActive = data.guildid && data.guildid[guildId] && data.guildid[guildId].secur.raidmode;
+
+        const newRaidModeValue = !isRaidModeActive;
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [`${botId}.${guildId}`, JSON.stringify({ secur: { raidmode: newRaidModeValue } })], (err) => {
+            if (err) {
+                console.error(err.message);
+                message.reply('Une erreur s\'est produite lors de la mise à jour du mode raid.');
+            } else {
+                if (newRaidModeValue) {
+                    guild.disableInvites(true)
+                    message.reply('Le mode raid est maintenant activé.');
+                } else {
+                    guild.disableInvites(false);
+                    message.reply('Le mode raid n\'est plus activé.');
+                }
+            }
+        });
+    },
+};

commands/antiraid/rolelimit.js

@@ -9,10 +9,22 @@ module.exports = {
     utilisation: 'rolelimit',
     category: 'antiraid',
 
-    async execute(interaction) {
-        const botId = interaction.client.user.id;
-        const guildId = interaction.guild.id;
+    async execute(message, args, client) {
+        const botId = message.client.user.id;
+        const guildId = message.guild.id;
+        const clear = args[0] === "clear"
+        console.log(clear)
+        if (args[0] === "clear") {
+            db.run('DELETE FROM gestion WHERE id LIKE ?', [`${botId}.${guildId}.rolelimits%`], (err) => {
+                if (err) {
+                    console.error(err.message);
+                     return message.reply('Une erreur s\'est produite lors de la suppression des rôles limités.');
+                } else {
+                    return message.reply('Tous les rôles limités ont été supprimés avec succès.');
+                }
+            });
         
+        }else {
         let limitedRoles = await new Promise((resolve, reject) => {
             db.get('SELECT value FROM gestion WHERE id = ?', [`${botId}.${guildId}.rolelimits`], (err, row) => {
                 if (err) {
@@ -27,7 +39,6 @@ module.exports = {
             limitedRoles = [];
         }
 
-        // Crée un embed avec les rôles limités
         const embed = new EmbedBuilder()
             .setTitle('Rôles limités')
             .setDescription(limitedRoles.map(role => `<@&${role.id}>: ${role.limit}`).join('\n') || 'Aucun rôle limité.')
@@ -45,7 +56,7 @@ module.exports = {
             .setStyle(ButtonStyle.Danger);
         const row = new ActionRowBuilder()
             .addComponents(addButton, removeButton);
-        const sentMessage = await interaction.reply({ embeds: [embed], components: [row], fetchReply: true });
+        const sentMessage = await message.reply({ embeds: [embed], components: [row], fetchReply: true });
 
 
         const filter = i => i.isButton() && i.customId.startsWith('rolelimit_') && i.user;
@@ -57,7 +68,7 @@ module.exports = {
                 const questionMessage = await i.reply('Mentionnez un rôle ou fournissez un ID de rôle à limiter.');
                 const filter = m => m.author && m.author.id === i.user.id;
                 const collected = await i.channel.awaitMessages({ filter, max: 1, time: 60000 });
-                const role = collected.first().mentions.roles.first() || interaction.guild.roles.cache.get(collected.first().content);
+                const role = collected.first().mentions.roles.first() || message.guild.roles.cache.get(collected.first().content);
                 if (!role) {
                     return i.followUp('Rôle invalide.');
                 }
@@ -103,7 +114,7 @@ module.exports = {
                 const questionMessage = await i.reply('Mentionnez un rôle ou fournissez un ID de rôle à supprimer.');
                 const filter = m => m.author && m.author.id === i.user.id;
                 const collected = await i.channel.awaitMessages({ filter, max: 1, time: 60000 });
-                const roleToRemove = collected.first().mentions.roles.first() || interaction.guild.roles.cache.get(collected.first().content);
+                const roleToRemove = collected.first().mentions.roles.first() || message.guild.roles.cache.get(collected.first().content);
                 if (!roleToRemove) {
                     return i.followUp('Rôle invalide.');
                 }
@@ -134,5 +145,6 @@ module.exports = {
         collector.on('end', collected => {
             sentMessage.edit({ components: [] });
         });
+    }
     },
 };

commands/antiraid/secur.js

@@ -0,0 +1,352 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+const { EmbedBuilder, ButtonBuilder, ButtonStyle, ActionRowBuilder } = require('discord.js');
+module.exports = {
+    name: 'secur',
+    aliases: ['antriraid'],
+    description: 'Affiche les configurations des antiraid.',
+    utilisation: 'secur',
+    category: 'antiraid',
+
+    async execute(message, args, client) {
+        const botId = client.user.id;
+        const guildId = message.guild.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) : {});
+            });
+        });
+
+        const guildData = data[guildId] || {};
+        const antiupdateConfig = guildData.antiupdate || {};
+        const antibotConfig = guildData.antibot || {};
+        const antiroleConfig = guildData.antirole || {};
+        const antichannelConfig = guildData.antichannel || {};
+        const antiwebhookConfig = guildData.antiwebhook || {};
+        const antibanConfig = guildData.antiban || {};
+        const antithreadConfig = guildData.antiThread || {};
+
+        const desac = new ButtonBuilder()
+        .setLabel('Désactiver tous les modules')
+        .setCustomId(`off_${guildId}`)
+        .setStyle(ButtonStyle.Danger);
+
+    const on = new ButtonBuilder()
+        .setLabel('Activer tous les modules')
+        .setCustomId(`on_${guildId}`)
+        .setStyle(ButtonStyle.Success);
+        const button1 = new ButtonBuilder()
+        .setLabel("◀")
+        .setCustomId('part1')
+        .setStyle(ButtonStyle.Secondary);
+    
+    const button2 = new ButtonBuilder()
+        .setLabel("▶")
+        .setCustomId('part2')
+        .setStyle(ButtonStyle.Secondary);
+        const row = new ActionRowBuilder()
+        .addComponents(button1, button2,on, desac);
+        const embed = new EmbedBuilder()
+    .setTitle('Configurations des antiraid - Partie 1')
+    .setColor('#0099ff')
+    .addFields(
+        { name: '**1・Anti-Update**', value: `**Actif**: \`${antiupdateConfig.type === 'off' || !antiupdateConfig.type ? '❌' : '✅'}\`** : **\`${antiupdateConfig.type ? antiupdateConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiupdateConfig.action || "Non Définie"}\``},
+        { name: '**2・Anti-bot**', value: `**Actif**: \`${antibotConfig.type === 'off' || !antibotConfig.type ? '❌' : '✅'}\`** : **\`${antibotConfig.type ? antibotConfig.type: "indéterminé"}\`\n **Sanction: **\`${antibotConfig.action || "Non Définie"}\``},
+        { name: '**3・Anti-Role**', value: `**Actif**: \`${antiroleConfig.type === 'off' || !antiroleConfig.type ? '❌' : '✅'}\`** : **\`${antiroleConfig.type ? antiroleConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiroleConfig.action || "Non Définie"}\``},
+        { name: '**4・Anti-Channel**', value: `**Actif**: \`${antichannelConfig.type === 'off' || !antichannelConfig.type ? '❌' : '✅'}\`** : **\`${antichannelConfig.type ? antichannelConfig.type: "indéterminé"}\`\n **Sanction: **\`${antichannelConfig.action || "Non Définie"}\``},
+        { name: '**5・Anti-Webhook**', value: `**Actif**: \`${antiwebhookConfig.type === 'off' || !antiwebhookConfig.type ? '❌' : '✅'}\`** : **\`${antiwebhookConfig.type ? antiwebhookConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiwebhookConfig.action || "Non Définie"}\``},
+        { name: '**6・Anti-Thread**', value: `**Actif**: \`${antithreadConfig.type === 'off' || !antithreadConfig.type ? '❌' : '✅'}\`** : **\`${antithreadConfig.type ? antithreadConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiwebhookConfig.action || "Non Définie"}\``},
+        { name: '**8・Anti-Ban**', value: `**Actif**: \`${antibanConfig.type === 'off' || !antibanConfig.type ? '❌' : '✅'}\`** : **\`${antibanConfig.type ? antibanConfig.type: "indéterminé"}\`\n **Sanction: **\`${antibanConfig.action || "Non Définie"}\`\n**Nombre: **\`${antibanConfig.number || 'N/A'}\``},
+    );
+
+
+        const sentMessage = await message.channel.send({ embeds: [embed], components: [row]  });
+        const filter = i => i.user.id === message.author.id;
+        const collector = sentMessage.createMessageComponentCollector({ filter, time: 60000 });
+        collector.on('collect', async i => {
+            if (i.customId.startsWith('on_')) {
+                const activationmessage = await i.reply({ content: "Les modules sont en train d'être activés", ephemeral: true });
+                const guildId = i.customId.split('_')[1];
+                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] = {};
+                }
+                let type = 'whitelist'
+                let status = 'on'
+                data[guildId].antibot = {
+                    type: type,
+                    action: data[guildId].antibot?.action || 'kick'
+                };
+                data[guildId].antichannel = {
+                    type: type,
+                    action: data[guildId].antichannel?.action || 'kick'
+                };
+                data[guildId].antiadmin = {
+                    type: type,
+                    action: data[guildId].antiadmin?.action || 'kick'
+                };
+                data[guildId].antieveryone = {
+                    status: status
+                };
+                data[guildId].antilink = {
+                    status: status,
+                    type: 'all'
+                };
+                data[guildId].antileak = {
+                    status: status,
+                };
+                data[guildId].antiThread = {
+                    type: type,
+                    action: data[guildId].antiThread?.action || 'kick'
+                };
+                data[guildId].antimention = {
+                    type: type,
+                    nombre: data[guildId].antimention?.nombre || 0 
+                };
+                data[guildId].antirole = {
+                    type: type,
+                    action: data[guildId].antirole?.action || 'kick'
+                };
+                data[guildId].antiupdate = {
+                    type: type,
+                    action: data[guildId].antiupdate?.action || 'kick'
+                };
+                data[guildId].antiwebhook = {
+                    type: type,
+                    action: data[guildId].antiwebhook?.action || 'kick'
+                };
+                data[guildId].antiban = {
+                    type: type,
+                    action: data[guildId].antiban?.action || 'kick',
+                    number:  data[guildId].antiban?.number || "10"
+                };
+                db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], async function(err) {
+                    if (err) {
+                        console.error(err.message);
+                        return i.reply({ content: 'Une erreur est survenue lors de la mise à jour de la configuration.', ephemeral: true });
+                    } else {
+                        activationmessage.edit({ content: "Les modules ont été activés avec succès." });
+                        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) : {});
+                            });
+                        });
+                        const guildData = data[guildId] || {};
+                        const antiupdateConfig = guildData.antiupdate || {};
+                        const antibotConfig = guildData.antibot || {};
+                        const antiroleConfig = guildData.antirole || {};
+                        const antichannelConfig = guildData.antichannel || {};
+                        const antiwebhookConfig = guildData.antiwebhook || {};
+                        const antibanConfig = guildData.antiban || {};
+                        const antithreadConfig = guildData.antiThread || {};
+                        const embed = new EmbedBuilder()
+                        .setTitle('Configurations des antiraid - Partie 1')
+                        .setColor('#0099ff')
+                        .addFields(
+                            { name: '**1・Anti-Update**', value: `**Actif**: \`${antiupdateConfig.type === 'off' || !antiupdateConfig.type ? '❌' : '✅'}\`** : **\`${antiupdateConfig.type ? antiupdateConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiupdateConfig.action || "Non Définie"}\``},
+                            { name: '**2・Anti-bot**', value: `**Actif**: \`${antibotConfig.type === 'off' || !antibotConfig.type ? '❌' : '✅'}\`** : **\`${antibotConfig.type ? antibotConfig.type: "indéterminé"}\`\n **Sanction: **\`${antibotConfig.action || "Non Définie"}\``},
+                            { name: '**3・Anti-Role**', value: `**Actif**: \`${antiroleConfig.type === 'off' || !antiroleConfig.type ? '❌' : '✅'}\`** : **\`${antiroleConfig.type ? antiroleConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiroleConfig.action || "Non Définie"}\``},
+                            { name: '**4・Anti-Channel**', value: `**Actif**: \`${antichannelConfig.type === 'off' || !antichannelConfig.type ? '❌' : '✅'}\`** : **\`${antichannelConfig.type ? antichannelConfig.type: "indéterminé"}\`\n **Sanction: **\`${antichannelConfig.action || "Non Définie"}\``},
+                            { name: '**5・Anti-Webhook**', value: `**Actif**: \`${antiwebhookConfig.type === 'off' || !antiwebhookConfig.type ? '❌' : '✅'}\`** : **\`${antiwebhookConfig.type ? antiwebhookConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiwebhookConfig.action || "Non Définie"}\``},
+                            { name: '**6・Anti-Thread**', value: `**Actif**: \`${antithreadConfig.type === 'off' || !antithreadConfig.type ? '❌' : '✅'}\`** : **\`${antithreadConfig.type ? antithreadConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiwebhookConfig.action || "Non Définie"}\``},
+                            { name: '**8・Anti-Ban**', value: `**Actif**: \`${antibanConfig.type === 'off' || !antibanConfig.type ? '❌' : '✅'}\`** : **\`${antibanConfig.type ? antibanConfig.type: "indéterminé"}\`\n **Sanction: **\`${antibanConfig.action || "Non Définie"}\`\n**Nombre: **\`${antibanConfig.number || 'N/A'}\``},
+                        );
+                
+                        sentMessage.edit({ embeds: [embed], components: [row]  });
+                    }
+                });
+            }else if (i.customId.startsWith('off_')) { 
+                const desacmessage = await i.reply({ content: "Les modules sont en train d'être désactivés", ephemeral: true });
+                const guildId = i.customId.split('_')[1];
+                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] = {};
+                }
+                let type = 'off'
+                let status = 'off'
+                data[guildId].antibot = {
+                    type: type,
+                    action: data[guildId].antibot?.action || 'kick'
+                };
+                data[guildId].antichannel = {
+                    type: type,
+                    action: data[guildId].antichannel?.action || 'kick'
+                };
+                data[guildId].antiadmin = {
+                    type: type,
+                    action: data[guildId].antiadmin?.action || 'kick'
+                };
+                data[guildId].antieveryone = {
+                    status: status
+                };
+                data[guildId].antilink = {
+                    status: status,
+                    type: 'all'
+                };
+                data[guildId].antileak = {
+                    status: status,
+                };
+                data[guildId].antiThread = {
+                    type: type,
+                    action: data[guildId].antiThread?.action || 'kick'
+                };
+                data[guildId].antimention = {
+                    type: type,
+                    nombre: data[guildId].antimention?.nombre || 0 
+                };
+                data[guildId].antirole = {
+                    type: type,
+                    action: data[guildId].antirole?.action || 'kick'
+                };
+                data[guildId].antiupdate = {
+                    type: type,
+                    action: data[guildId].antiupdate?.action || 'kick'
+                };
+                data[guildId].antiwebhook = {
+                    type: type,
+                    action: data[guildId].antiwebhook?.action || 'kick'
+                };
+                data[guildId].antiban = {
+                    type: type,
+                    action: data[guildId].antiban?.action || 'kick',
+                    number:  data[guildId].antiban?.number || "10"
+                };
+                db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], async function(err) {
+                    if (err) {
+                        console.error(err.message);
+                        return desacmessage.edit({ content: 'Une erreur est survenue lors de la mise à jour de la configuration.', ephemeral: true });
+                    } else {
+                        desacmessage.edit({ content: "Les modules ont été désactivés avec succès.", ephemeral: true });
+
+                        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) : {});
+                            });
+                        });
+                        const guildData = data[guildId] || {};
+                        const antiupdateConfig = guildData.antiupdate || {};
+                        const antibotConfig = guildData.antibot || {};
+                        const antiroleConfig = guildData.antirole || {};
+                        const antichannelConfig = guildData.antichannel || {};
+                        const antiwebhookConfig = guildData.antiwebhook || {};
+                        const antibanConfig = guildData.antiban || {};
+                        const antithreadConfig = guildData.antiThread || {};
+                        const embed = new EmbedBuilder()
+                        .setTitle('Configurations des antiraid - Partie 1')
+                        .setColor('#0099ff')
+                        .addFields(
+                            { name: '**1・Anti-Update**', value: `**Actif**: \`${antiupdateConfig.type === 'off' || !antiupdateConfig.type ? '❌' : '✅'}\`** : **\`${antiupdateConfig.type ? antiupdateConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiupdateConfig.action || "Non Définie"}\``},
+                            { name: '**2・Anti-bot**', value: `**Actif**: \`${antibotConfig.type === 'off' || !antibotConfig.type ? '❌' : '✅'}\`** : **\`${antibotConfig.type ? antibotConfig.type: "indéterminé"}\`\n **Sanction: **\`${antibotConfig.action || "Non Définie"}\``},
+                            { name: '**3・Anti-Role**', value: `**Actif**: \`${antiroleConfig.type === 'off' || !antiroleConfig.type ? '❌' : '✅'}\`** : **\`${antiroleConfig.type ? antiroleConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiroleConfig.action || "Non Définie"}\``},
+                            { name: '**4・Anti-Channel**', value: `**Actif**: \`${antichannelConfig.type === 'off' || !antichannelConfig.type ? '❌' : '✅'}\`** : **\`${antichannelConfig.type ? antichannelConfig.type: "indéterminé"}\`\n **Sanction: **\`${antichannelConfig.action || "Non Définie"}\``},
+                            { name: '**5・Anti-Webhook**', value: `**Actif**: \`${antiwebhookConfig.type === 'off' || !antiwebhookConfig.type ? '❌' : '✅'}\`** : **\`${antiwebhookConfig.type ? antiwebhookConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiwebhookConfig.action || "Non Définie"}\``},
+                            { name: '**6・Anti-Thread**', value: `**Actif**: \`${antithreadConfig.type === 'off' || !antithreadConfig.type ? '❌' : '✅'}\`** : **\`${antithreadConfig.type ? antithreadConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiwebhookConfig.action || "Non Définie"}\``},
+                            { name: '**8・Anti-Ban**', value: `**Actif**: \`${antibanConfig.type === 'off' || !antibanConfig.type ? '❌' : '✅'}\`** : **\`${antibanConfig.type ? antibanConfig.type: "indéterminé"}\`\n **Sanction: **\`${antibanConfig.action || "Non Définie"}\`\n**Nombre: **\`${antibanConfig.number || 'N/A'}\``},
+                        );               
+                        sentMessage.edit({ embeds: [embed], components: [row]  });
+                    }
+                });
+
+            }else if (i.customId === 'part1') {
+                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) : {});
+                    });
+                });
+                const guildData = data[guildId] || {};
+                const antiupdateConfig = guildData.antiupdate || {};
+                const antibotConfig = guildData.antibot || {};
+                const antiroleConfig = guildData.antirole || {};
+                const antichannelConfig = guildData.antichannel || {};
+                const antiwebhookConfig = guildData.antiwebhook || {};
+                const antibanConfig = guildData.antiban || {};
+                const antithreadConfig = guildData.antiThread || {};
+                const embed1 = new EmbedBuilder()
+                .setTitle('Configurations des antiraid - Partie 1')
+                .setColor('#0099ff')
+                .addFields(
+                    { name: '**1・Anti-Update**', value: `**Actif**: \`${antiupdateConfig.type === 'off' || !antiupdateConfig.type ? '❌' : '✅'}\`** : **\`${antiupdateConfig.type ? antiupdateConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiupdateConfig.action || "Non Définie"}\``},
+                    { name: '**2・Anti-bot**', value: `**Actif**: \`${antibotConfig.type === 'off' || !antibotConfig.type ? '❌' : '✅'}\`** : **\`${antibotConfig.type ? antibotConfig.type: "indéterminé"}\`\n **Sanction: **\`${antibotConfig.action || "Non Définie"}\``},
+                    { name: '**3・Anti-Role**', value: `**Actif**: \`${antiroleConfig.type === 'off' || !antiroleConfig.type ? '❌' : '✅'}\`** : **\`${antiroleConfig.type ? antiroleConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiroleConfig.action || "Non Définie"}\``},
+                    { name: '**4・Anti-Channel**', value: `**Actif**: \`${antichannelConfig.type === 'off' || !antichannelConfig.type ? '❌' : '✅'}\`** : **\`${antichannelConfig.type ? antichannelConfig.type: "indéterminé"}\`\n **Sanction: **\`${antichannelConfig.action || "Non Définie"}\``},
+                    { name: '**5・Anti-Webhook**', value: `**Actif**: \`${antiwebhookConfig.type === 'off' || !antiwebhookConfig.type ? '❌' : '✅'}\`** : **\`${antiwebhookConfig.type ? antiwebhookConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiwebhookConfig.action || "Non Définie"}\``},
+                    { name: '**6・Anti-Thread**', value: `**Actif**: \`${antithreadConfig.type === 'off' || !antithreadConfig.type ? '❌' : '✅'}\`** : **\`${antithreadConfig.type ? antithreadConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiwebhookConfig.action || "Non Définie"}\``},
+                    { name: '**8・Anti-Ban**', value: `**Actif**: \`${antibanConfig.type === 'off' || !antibanConfig.type ? '❌' : '✅'}\`** : **\`${antibanConfig.type ? antibanConfig.type: "indéterminé"}\`\n **Sanction: **\`${antibanConfig.action || "Non Définie"}\`\n**Nombre: **\`${antibanConfig.number || 'N/A'}\``},
+                ); 
+                await i.update({ embeds: [embed1], components: [row] });
+            } else if (i.customId === 'part2') {
+                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) : {});
+                    });
+                });
+                const guildData = data[guildId] || {};
+                const antilinkConfig = guildData.antilink || {};
+                const antieveryoneConfig = guildData.antieveryone || {};
+                const antileakConfig = guildData.antileak || {};
+                const antijoinConfig = guildData.antijoin || {};
+                const antiadminConfig = guildData.antiadmin || {};
+                const antimentionConfig = guildData.antimention || {};
+                const RaidpingConfig = guildData.raidping || 'Non Définie';
+                const embed2 = new EmbedBuilder()
+                .setTitle('Configurations des antiraid - Partie 2')
+                .setColor('#0099ff')
+                .addFields(
+                    { name: '**7・Anti-Admin**', value: `**Actif**: \`${antiadminConfig.type === 'off' || !antiadminConfig.type ? '❌' : '✅'}\`** : **\`${antiadminConfig.type ? antiadminConfig.type: "indéterminé"}\`\n **Sanction: **\`${antiadminConfig.action || "Non Définie"}\``},
+                    { name: '**9・Anti-MassMention**', value: `**Actif**: \`${antimentionConfig.type === 'off' || !antimentionConfig.type ? '❌' : '✅'}\`** : **\`${antimentionConfig.type ? antimentionConfig.type: "indéterminé"}\`\n**Nombre: **\`${antimentionConfig.nombre || 'N/A'}\``},
+                    { name: '**10・Anti-Link**', value: `**Actif**: \`${antilinkConfig.status === 'off' || !antilinkConfig.status ? '❌' : '✅'}\`** : **\`${antilinkConfig.status ? antilinkConfig.status: "indéterminé"}\`\n **Type: **\`${antilinkConfig.type || "Non Définie"}\``},
+                    { name: '**11・Anti-Everyone**', value: `**Actif**: \`${antieveryoneConfig.status === 'off' || !antieveryoneConfig.status ? '❌' : '✅'}\`** : **\`${antieveryoneConfig.status ? antieveryoneConfig.status: "indéterminé"}\``},
+                    { name: '**12・Anti-Leak**', value: `**Actif**: \`${antileakConfig.status === 'off' || !antileakConfig.status ? '❌' : '✅'}\`** : **\`${antileakConfig.status ? antileakConfig.status: "indéterminé"}\``},
+                    { name: '**14・Anti-Join**', value: `**Actif**: \`${antijoinConfig.status === 'off' || !antijoinConfig.status ? '❌' : '✅'}\`** : **\`${antijoinConfig.status ? antijoinConfig.status: "indéterminé"}\``},
+                    { name: '**14・Creation-Limit**', value: `**Actif**: \`${guildData.creationLimit === 'off' || !guildData.creationLimit ? '❌' : '✅'}\`\n** temps **\`${guildData.creationLimit ? guildData.creationLimit : "indéterminé"}\``},
+                    { name: '**15・RaidPing**', value: `\`${RaidpingConfig || 'Non definie'}\``}
+                );
+                await i.update({ embeds: [embed2], components: [row] });
+            }
+        });
+        collector.on('end', collected => {
+            const disabledRow = new ActionRowBuilder()
+                .addComponents(button1.setDisabled(true),button2.setDisabled(true),on.setDisabled(true), desac.setDisabled(true) );
+            sentMessage.edit({ components: [disabledRow] });
+        });
+    },
+};

commands/botcontrol/invite.js

@@ -8,6 +8,7 @@ module.exports = {
     utilisation: 'invite [guildId]',
     category: 'botcontrol',
     async execute(message, args, client) {
+        try{
         if (!args[0]) {
             return message.reply('Veuillez fournir l\'ID du serveur.');
         }
@@ -44,5 +45,9 @@ module.exports = {
         }).then(async (invite) => {
             message.channel.send(`Invitation créée pour le serveur ${guild.name} : ${invite.url}`);
         })
+    }catch(arr) {
+        return message.reply("Je n'est pas reussie a crée une invitation")
+    }
+
     },
 };

commands/botcontrol/leave.js

@@ -10,8 +10,6 @@ module.exports = {
     category: 'botcontrol',
 
     async execute(message, args, client) {
-
-        // If an ID is provided, try to get the guild with that ID
         const guildId = args[0];
         if (guildId) {
             const guild = client.guilds.cache.get(guildId);

commands/botcontrol/reload.js

@@ -1,3 +1,5 @@
+const fs = require('fs');
+const path = require('path');
 module.exports = {
     name: 'reload',
     description: 'Recharge une commande spécifique',
@@ -8,25 +10,35 @@ module.exports = {
         const commandName = args[0].toLowerCase(); 
         const command = message.client.commands.get(commandName);
         if (args[0].toLowerCase() === 'all') {
-            message.reply('Toutes les commandes vont être rechargées.')
+            message.reply('Toutes les commandes vont être rechargées....')
             .then(async sendmessage => {
-                const commands = Array.from(message.client.commands.values());
-                const reloadPromises = commands.map(async (command) => {
-                    const commandFile = command.file;
-                    delete require.cache[require.resolve(commandFile)];
-            
+                message.client.commands.clear();
+                let count = 0; 
+                const loadCommands = (dir) => {
+                    fs.readdirSync(path.join(__dirname, dir)).forEach(file => {
+                        const filePath = path.join(__dirname, dir, file);
+                        if (fs.statSync(filePath).isDirectory()) {
+                            count += loadCommands(path.join(dir, file));
+                        } else if (file.endsWith('.js')) {
                             try {
-                        const newCommand = require(commandFile);
-                        newCommand.file = commandFile;
-                        message.client.commands.set(newCommand.name, newCommand);
-                        await sendmessage.edit(`La commande ${newCommand.name} a été rechargée.`);
+                                delete require.cache[require.resolve(filePath)];
+                                const command = require(filePath);
+                                command.file = filePath;
+                                message.client.commands.set(command.name, command);
+                                if (command.aliases) {
+                                    command.aliases.forEach(alias => {
+                                        message.client.commands.set(alias, command);
+                                    });
+                                }
+                                count++;
                             } catch (error) {
-                        console.error(`Erreur lors du rechargement de la commande ${command.name}:`, error);
-                        await message.reply(`Une erreur est survenue lors du rechargement de la commande ${command.name}: ${error.message}`);
+                                console.error(`Failed to load file: ${filePath}`);
+                                console.error(error);
+                            }
                         }
                     });
-            
-                await Promise.all(reloadPromises);
+                }
+                loadCommands('../../commands');
                 await sendmessage.edit('Toutes les commandes ont été rechargées.');
             })
             .catch(error => {

commands/botcontrol/set.js

@@ -1,3 +1,6 @@
+const axios = require('axios');
+const fs = require('fs');
+const { send } = require('process');
 module.exports = {
   name: 'set',
   aliases: ['changer'],
@@ -7,11 +10,42 @@ module.exports = {
   category: 'botcontrol',
 
     async execute(message, args, client) {
-      if (args.length <  2) {
-        return message.reply('Veuillez fournir un paramètre parmis `name` ou `pic` pour sa valeur.');
-      }
-  
       const setting = args[0];
+      if (setting === 'banner') {
+        const sendmessage = await message.reply("\`🔃\` La banniere est entrain de ce mettre sur le bot");
+        const attachment = message.attachments.first();
+        //if (!attachment || !attachment.url.endsWith('.gif')) {
+          //  return message.reply("Veuillez attacher un fichier .gif pour utiliser comme nouvelle bannière.");
+        //}
+        try {
+            const responses = await axios.get(attachment.url, { responseType: 'arraybuffer' });
+            const buffer = Buffer.from(responses.data, 'binary');
+            const base64Image = buffer.toString('base64');
+
+            let response = await axios("https://discord.com/api/v9/users/@me", {
+                method: "PATCH",
+                headers: {
+                    Authorization: `Bot ${client.token}`,
+                    "Content-Type": "application/json"
+                },
+                data: JSON.stringify({
+                    banner: `data:image/gif;base64,${base64Image}`
+                })
+            });
+
+            if (response.status === 200) {
+                return sendmessage.edit("\`✅\`Le bot a bien mis à jour sa bannière");
+            } else {
+              console.log(`Unable to update banner : ${response.statusText}`);
+              let responseBody = await response.text();
+              console.log(`Response : ${responseBody}`);
+                return sendmessage.edit("\`❌\`Un problème est survenu durant la mise à jour de la bannière du bot.");
+            }
+        } catch (err) {
+            console.error(`An error occurred while updating the banner : ${err}`);
+            return sendmessage.edit("\`❌\`Un problème est survenu durant la mise à jour de la bannière du bot.");
+        }
+    }
 
       if (setting === 'name') {
         const value = args.slice(1).join(' ');
@@ -28,20 +62,33 @@ module.exports = {
           return message.reply('Veuillez fournir un nom valide.');
         }
       } else if (setting === 'pic') {
+if (message.attachments.size > 0) {
+  const sendmessage = await message.reply("\`🔃\` L'avatar est entrain de ce mettre sur le bot");
+  const attachment = message.attachments.first();
+  try {
+      await client.user.setAvatar(attachment.url);
+      return sendmessage.edit("\`✅\`Le bot a bien mis à jour son avatar");
+  } catch (error) {
+      console.error(error);
+      return message.reply('Une erreur est survenue lors de la tentative de mise à jour de mon avatar.');
+  }
+} else {
   const value = args[1];
   if (value && value.startsWith('http')) {
+    const sendmessage = await message.reply("\`🔃\` L'avatar est entrain de ce mettre sur le bot");
       try {
           await client.user.setAvatar(value);
-            return message.reply('Mon avatar a été mis à jour avec succès.');
+          return sendmessage.edit("\`✅\`Le bot a bien mis à jour son avatar");
       } catch (error) {
           console.error(error);
           return message.reply('Une erreur est survenue lors de la tentative de mise à jour de mon avatar.');
       }
   } else {
       return message.reply('Veuillez fournir un URL d\'image valide.');
+  }
         }
       } else {
-        return message.reply('Paramètre invalide. Veuillez utiliser "name" ou "pic".');
+        return message.reply('Paramètre invalide. Veuillez utiliser \`name\` ou \`pic\` ou \`banner\`.');
       }
     },
   };

commands/botcontrol/setactivity.js

@@ -1,5 +1,6 @@
 const { EmbedBuilder, StringSelectMenuBuilder, ActionRowBuilder, ActivityType } = require("discord.js");
-
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
 module.exports = {
   name: 'setactivity',
   description: 'Changer la présence du bot',
@@ -11,7 +12,7 @@ module.exports = {
   async execute(message, args, client) {
     const author = message.author;
 
-    let currentActivitie = client.user.presence.activities[0];
+    let currentActivitie = client.user.presence.activities[0] || "aucun status";
 
     const embed = new EmbedBuilder()
       .setTitle('Changement d\'activité')
@@ -80,12 +81,13 @@ module.exports = {
 
         interaction.reply(`Veuillez entrer le message que vous voulez afficher pour l'activité ${value}`);
         filter = (message) => message.author.id === author.id;
-        const messageCollector = message.channel.createMessageCollector({ filter, time: 60000 });
+        const messageCollector = message.channel.createMessageCollector({ filter , max: 1 , time: 60000 });
         messageCollector.on('collect', async (messageCollect) => {
           const text = messageCollect.content;
           const url = 'https://www.twitch.tv/valou336_ytb';
 
           if (!client.user) return;
+          let type, status;
           if (value === 'playing') {
              client.user.setPresence({
                activities: [{
@@ -94,6 +96,8 @@ module.exports = {
                  url: url
                }]
              });
+             type = 'playing';
+             status = text;
           } else if (value === 'streaming') {
              client.user.setPresence({
                activities: [{
@@ -102,6 +106,8 @@ module.exports = {
                  url: url
                }]
              });
+             type = 'streaming';
+             status = text;
           } else if (value === 'listening') {
              client.user.setPresence({
                activities: [{
@@ -110,6 +116,8 @@ module.exports = {
                  url: url
                }]
              });
+             type = 'listening';
+             status = text;
           } else if (value === 'watching') {
              client.user.setPresence({
                activities: [{
@@ -118,6 +126,8 @@ module.exports = {
                  url: url
                }]
              });
+             type = 'watching';
+             status = text;
           } else if (value === 'competing') {
              client.user.setPresence({
                activities: [{
@@ -126,9 +136,20 @@ module.exports = {
                  url: url
                }]
              });
+             type = 'competing';
+             status = text;
           } else {
              return;
           }
+         
+          db.run('INSERT OR REPLACE INTO status (botId, type, status) VALUES (?, ?, ?)', [client.user.id, type, status], (err) => {
+            if (err) {
+                console.error(err.message);
+            } else {
+            }
+        });
+        
+           
         });
       }
     });

commands/botcontrol/setbanner.js

@@ -0,0 +1,48 @@
+const axios = require('axios');
+const fs = require('fs');
+const { send } = require('process');
+
+module.exports = {
+    name: 'setbanner',
+    description: "Changer la bannire du bot",
+    emote: '🚪', 
+    utilisation: 'setbanner [banner]',
+    category: 'botcontrol',
+
+    async execute(message, args, client) {
+        const sendmessage = await message.reply("\`🔃\` La banniere est entrain de ce mettre sur le bot")
+        //if (message.attachments.size > 0 && /\.gif\s*$/i.test(message.attachments.first().url)) {
+            const attachment = message.attachments.first();
+            try {
+                const responses = await axios.get(attachment.url, { responseType: 'arraybuffer' });
+                const buffer = Buffer.from(responses.data, 'binary');
+                const base64Image = buffer.toString('base64');
+
+                let response = await axios("https://discord.com/api/v9/users/@me", {
+                    method: "PATCH",
+                    headers: {
+                        Authorization: `Bot ${client.token}`,
+                        "Content-Type": "application/json"
+                    },
+                    data: JSON.stringify({
+                        banner: `data:image/gif;base64,${base64Image}`
+                    })
+                });
+
+                if (response.status === 200) {
+                    sendmessage.edit("\`✅\`Le bot a bien mis à jour sa bannière");
+                } else {
+                    sendmessage.edit("\`❌\`Un problème est survenu durant la mise à jour de la bannière du bot.");
+                    console.log(`Unable to update banner : ${response.statusText}`);
+                    let responseBody = await response.text();
+                    console.log(`Response : ${responseBody}`);
+                }
+            } catch (err) {
+                console.error(`An error occurred while updating the banner : ${err}`);
+                sendmessage.edit("\`❌\`Un problème est survenu durant la mise à jour de la bannière du bot.");
+            }
+        //} else {
+          //  console.log("Please attach a .gif file to use as the new banner.");
+        //}
+    },
+};

commands/game/2048.js

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

commands/game/claque.js

@@ -0,0 +1,46 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+    name: "claque",
+    category: 'game',
+    description: "Fait une claque à un utilisateur mentionné ou à un utilisateur dont le nom est fourni en argument.",
+    emote: '👊',
+    utilisation : '+claque [@user]',
+    async execute(message, args, client) {
+        let user = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
+        claque = ['https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExb25yejVkZzFjd2dhbXJla2UyZWx6cmN5dGt4bzBuYXNxamNuZ2ZuaCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/gSIz6gGLhguOY/giphy.gif', 'https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExMGZkcHQ4YXZ1N3M4YzhlenVscnFtbmltdHhxN25vemFpbHRtejcwNyZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/XDRoTw2Fs6rlIW7yQL/giphy.gif', 'https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExaW9iOWQ5NTYxMWV6YjUxbWMwdG5idXJqdjgxbHdtc2xwZGM5dXI3ayZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/mEtSQlxqBtWWA/giphy.gif', 'https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExb2xlbDc5dW02aTRiMmx5amNrd29venFiaG5sbGQ0anhobWt2M3A5OSZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/uG3lKkAuh53wc/giphy.gif','https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExZjFhZXpmZHd3aXF2b3dmaGM4cmZxNHdmMDdxMW11ZzU0ZXd4a2U2MCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/3XlEk2RxPS1m8/giphy.gif','https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExZDE3MXA0cGdxemoxZDdsdGdma3h3Y3pneHh5M214MzE2ZGx6cnJhZiZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/qyjexFwQwJp9yUvMxq/giphy.gif','https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExcWxwdWUyNDZ6MG04Z2JxY2h5d2xwZXBoZ2d3NHhmMXNzejk1cDBudCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/lX03hULhgCYQ8/giphy.gif', 'https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExOW5iNWlqOXNzajZkdWN5Y212ZWcwenA3ZW5zamI1Y21qODQzams4MyZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/u8maN0dMhVWPS/giphy.gif']; 
+        let randomClap = claque[Math.floor(Math.random() * claque.length)];
+
+        if (user) {
+            let embed = new EmbedBuilder()
+                .setDescription(`👊 **${message.author.username}** fait une claque à **${user.user.username}**`)
+                .setImage(randomClap)
+                .setTimestamp()
+                .setAuthor({name: message.author.username, iconURL: message.author.avatarURL({ dynamic: true })})
+                .setFooter({text: client.user.username, iconURL: client.user.displayAvatarURL({ dynamic: true })});
+            message.channel.send({ embeds: [embed] });
+        } else {
+            if (args[0]) {
+                let member = message.guild.members.cache.find(m => m.displayName.toLowerCase().indexOf(args[0].toLowerCase()) > -1);
+                if (!member) member = client;
+                let embed = new EmbedBuilder()
+                    .setDescription(`👊 **${message.author.username}** fait une claque à **${member.user.username}**`)
+                    .setImage(randomClap)
+                    .setTimestamp()
+                    .setAuthor({name: message.author.username, iconURL: message.author.avatarURL({ dynamic: true })})
+                    .setFooter({text: client.user.username, iconURL: client.user.displayAvatarURL({ dynamic: true })});
+                message.channel.send({ embeds: [embed] });
+            } else {
+                let randomMember = message.guild.members.cache.random();
+
+                let embed = new EmbedBuilder()
+                    .setDescription(`👊 **${message.author.username}** fait une claque à **${randomMember.user.username}**`)
+                    .setImage(randomClap)
+                    .setTimestamp()
+                    .setAuthor({name: message.author.username, iconURL: message.author.avatarURL({ dynamic: true })})
+                    .setFooter({text: client.user.username, iconURL: client.user.displayAvatarURL({ dynamic: true })});
+                message.channel.send({ embeds: [embed] });
+            }
+        }
+    },
+};

commands/game/demineur.js

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

commands/game/epicgamer.js

@@ -0,0 +1,20 @@
+const { EmbedBuilder } = require('discord.js');
+
+module.exports = {
+    name: 'epicgamer',
+    description: 'Évaluez votre statut de gamer épique.',
+    emote: '🎮',
+    utilisation: 'epicgamer ',
+    category: 'game',
+
+    async execute(message, args, client) {
+        var result = Math.ceil(Math.random() * 100);
+
+        const embed = new EmbedBuilder()
+            .setTitle(`🎮・Epic gamer rate`)
+            .setDescription(`You are ${result}% epic gamer!`)
+            .setColor('#0099ff'); 
+
+        message.reply({ embeds: [embed] });
+    },
+};

commands/game/fasttype.js

@@ -53,7 +53,5 @@ module.exports = {
 
         Game.startGame();
 
-        Game.on('gameOver', result => {
-        });
     },
 };

commands/game/findemoji.js

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

commands/game/flood.js

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

commands/game/kiss.js

@@ -0,0 +1,46 @@
+const { EmbedBuilder } = require("discord.js");
+
+module.exports = {
+    name: "kiss",
+    category: 'game',
+    description: "Fait un bisou à un utilisateur mentionné ou à un utilisateur dont le nom est fourni en argument.",
+    emote: '💋',
+    utilisation : '+kiss [@user]',
+    async execute(message, args, client) {
+        let user = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
+        kiss = ['https://cdn.weeb.sh/images/rymvn6_wW.gif','https://cdn.weeb.sh/images/H1a42auvb.gif','https://cdn.weeb.sh/images/H1Gx2aOvb.gif','https://cdn.weeb.sh/images/rJrCj6_w-.gif','https://cdn.weeb.sh/images/B13D2aOwW.gif','https://cdn.weeb.sh/images/BJLP3a_Pb.gif','https://cdn.weeb.sh/images/Hy-oQl91z.gif','https://cdn.weeb.sh/images/SJINn6OPW.gif','https://cdn.weeb.sh/images/ByiMna_vb.gif','https://cdn.weeb.sh/images/rymvn6_wW.gif','https://cdn.weeb.sh/images/BJSdQRtFZ.gif','https://cdn.weeb.sh/images/S1PCJWASf.gif','https://cdn.weeb.sh/images/SJ3dXCKtW.gif','https://cdn.weeb.sh/images/HJlWhpdw-.gif','https://cdn.weeb.sh/images/rkde2aODb.gif','https://cdn.weeb.sh/images/SybPhp_wZ.gif','https://cdn.weeb.sh/images/rkFSiEedf.gif','https://cdn.weeb.sh/images/r1cB3aOwW.gif','https://cdn.weeb.sh/images/BJv0o6uDZ.gif','https://cdn.weeb.sh/images/B13D2aOwW.gif','https://cdn.weeb.sh/images/Skv72TuPW.gif','https://cdn.weeb.sh/images/S1qZksSXG.gif','https://cdn.weeb.sh/images/Sk1k3TdPW.gif','https://cdn.weeb.sh/images/S1-KXsh0b.gif','https://cdn.weeb.sh/images/B1yv36_PZ.gif','https://cdn.weeb.sh/images/BJx2l0ttW.gif']
+        let randomKiss = kiss[Math.floor(Math.random() * kiss.length)];
+
+        if (user) {
+            let embed = new EmbedBuilder()
+                .setDescription(`💋 **${message.author.username}** fait un bisou à **${user.user.username}**`)
+                .setImage(randomKiss)
+                .setTimestamp()
+                .setAuthor({name: message.author.username,iconURL:  message.author.avatarURL({ dynamic: true })})
+                .setFooter({text: client.user.username,iconURL:  client.user.displayAvatarURL({ dynamic: true })});
+            message.channel.send({ embeds: [embed] });
+        } else {
+            if (args[0]) {
+                let member = message.guild.members.cache.find(m => m.displayName.toLowerCase().indexOf(args[0].toLowerCase()) > -1);
+                if (!member) member = client;
+                let embed = new EmbedBuilder()
+                    .setDescription(`💋 **${message.author.username}** fait un bisou à **${member.user.username}**`)
+                    .setImage(randomKiss)
+                    .setTimestamp()
+                    .setAuthor({name: message.author.username,iconURL:  message.author.avatarURL({ dynamic: true })})
+                    .setFooter({text: client.user.username,iconURL:  client.user.displayAvatarURL({ dynamic: true })});
+                message.channel.send({ embeds: [embed] });
+            } else {
+                let randomMember = message.guild.members.cache.random();
+
+                let embed = new EmbedBuilder()
+                    .setDescription(`💋 **${message.author.username}** fait un bisou à **${randomMember.user.username}**`)
+                    .setImage(randomKiss)
+                    .setTimestamp()
+                    .setAuthor({name: message.author.username,iconURL:  message.author.avatarURL({ dynamic: true })})
+                    .setFooter({text: client.user.username,iconURL:  client.user.displayAvatarURL({ dynamic: true })});
+                message.channel.send({ embeds: [embed] });
+            }
+        }
+    },
+};

commands/game/lc.js

@@ -32,7 +32,7 @@ module.exports = {
         const percent = parseInt(string.substr(0, 2), 10);
 
         const embed = new Discord.EmbedBuilder()
-        .setTitle("❤️ LoveCalc")
+        .setTitle("💖 Calcul de l'amour 💖")
         .setDescription(`${firstMember.user.username} et ${secondMember.user.username} s'aime à ${percent}% `)
           .setImage(firstMember.user.displayAvatarURL({ dynamic: true }) + secondMember.user.displayAvatarURL({ dynamic: true }))
           .setColor('#C71585')

commands/game/marry.js

@@ -6,7 +6,7 @@ module.exports = {
     description: 'Proposez en mariage à un utilisateur',
     emote: '💍', 
     category: 'game', 
-    utilisation: '+marry @user',
+    utilisation: 'marry @user',
     async execute(message, args, client) {
         const targetUser = message.mentions.users.first() || message.guild.members.cache.get(args[0]);
         if (!targetUser) {
@@ -28,7 +28,7 @@ module.exports = {
                     .setStyle(ButtonStyle.Success),
             );
 
-        message.channel.send({ content: `${targetUser}`, components: [row] });
+        message.channel.send({ content: `${targetUser} voulez vous vous marier avec <@${message.author.id}>`, components: [row] });
     },
 };
 async function checkIfMarried(userId, client) {

commands/game/morpion.js

@@ -39,6 +39,5 @@ module.exports = {
         });
 
         const result = await Game.startGame();
-        console.log(result); // => { result... }
     },
 };

commands/game/rickroll.js

@@ -0,0 +1,27 @@
+const { EmbedBuilder } = require('discord.js');
+
+module.exports = {
+    name: 'rickroll',
+    description: 'Never gonna give you up.',
+    emote: '😂',
+    utilisation: 'rickroll ',
+    category: 'game',
+
+    async execute(message, args, client) {
+        const roll = [
+            "Never gonna give you up",
+            "Never gonna let you down",
+            "Never gonna run around and desert you",
+            "Never gonna make you cry",
+            "Never gonna say goodbye",
+            "Never gonna tell a lie and hurt you",
+        ];
+        const rick = roll[Math.floor(Math.random() * roll.length)];
+
+        const embed = new EmbedBuilder()
+            .setTitle(`😂・${rick}`)
+            .setImage('https://i.pinimg.com/originals/88/82/bc/8882bcf327896ab79fb97e85ae63a002.gif');
+
+        message.reply({ embeds: [embed] });
+    },
+};

commands/game/slot.js

@@ -20,7 +20,5 @@ module.exports = {
           });
           
           Game.startGame();
-          Game.on('gameOver', result => {
-          });
     },
 };

commands/game/unmarry.js

@@ -5,7 +5,7 @@ module.exports = {
     description: 'Dissoudre un mariage',
     emote: '💍',
     category: 'game', 
-    utilisation: '+unmarry',
+    utilisation: 'unmarry',
     execute(message, args, client) {
 
         checkIfMarried(message.author.id, client).then(isMarried => {

commands/game/wordle.js

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

commands/gestion/bypass.js

@@ -0,0 +1,21 @@
+module.exports = {
+    name: 'dero',
+    description: "Permet de donner des permissions de gestion à un rôle spécifique sur tous les salons du serveur.",
+    category: 'gestion',
+    emote: '🔑',
+    utilisation: 'dero @role/id',
+    async execute(message, args, client) {
+        const role = message.mentions.roles.first() || message.guild.roles.cache.get(args[0]);
+        if (!role) {
+            message.reply('Veullez mentionner un role')
+        }
+        try {
+            message.guild.channels.cache.forEach(channel => {
+                channel.permissionOverwrites.edit(role, {"ManageChannels": true ,"ViewChannel": true , "ManageThreads": true, "ManageRoles": true});
+            });
+            message.reply(`Le rôle ${role} a maintenant des dérogations sur tous les salons du serveur.`);
+        } catch (error) {
+            message.reply("Je n'ai pas la permission de gérer les salons.");
+        }
+    },
+};

commands/gestion/change.js

@@ -1,7 +1,6 @@
-const fs = require('fs');
-const path = require('path');
-const sqlite3 = require('sqlite3').verbose();
 
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
 module.exports = {
     name: 'change',
     aliases: ['permchange'],
@@ -13,6 +12,40 @@ module.exports = {
     async execute(message, args, client) {
         const botId = client.user.id;
         const unchangeableCommands = ['owner', 'unowner', 'buyer'];
+        if (args[1].toLowerCase() === 'off') {
+            
+        const commandName = args[0].toLowerCase();
+        if (unchangeableCommands.includes(commandName)) {
+            return message.reply(`La commande ${commandName} ne peut pas être modifiée.`);
+        }
+
+        if (!client.commands.has(commandName)) {
+            return message.reply('Cette commande n\'existe pas.');
+        }
+        
+
+        let permissions = 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 (!permissions.permissions) {
+            permissions.permissions = {};
+        }
+        permissions.permissions[commandName] = 'off';
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(permissions)], (err) => {
+            if (err) {
+                console.error(err.message);
+            }else {
+                return message.reply(`La commande \`${commandName}\` a été désactivée.`);
+            }
+        });
+        }else {
 
         if (args.length <  2) {
             return message.reply('Veuillez spécifier une commande et un niveau de permission.');
@@ -40,7 +73,6 @@ module.exports = {
             return message.reply('Cette commande n\'existe pas.');
         }
 
-        const db = new sqlite3.Database('myDatabase.db');
         let permissions = await new Promise((resolve, reject) => {
             db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                 if (err) {
@@ -63,5 +95,6 @@ module.exports = {
         });
 
         message.reply(`Le niveau de permission de la commande ${commandName} a été changé à ${permissionLevel}.`);
+    }
     },
 };

commands/gestion/changeall.js

@@ -1,7 +1,6 @@
-const fs = require('fs');
-const path = require('path');
-const sqlite3 = require('sqlite3').verbose();
 
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
 module.exports = {
     name: 'changeall',
     aliases: ['permchangeall'],
@@ -18,14 +17,16 @@ module.exports = {
             return message.reply('Veuillez spécifier un niveau de permission actuel et un nouveau niveau de permission.');
         }
 
-        const currentPermissionLevel = parseInt(args[0]);
-        const newPermissionLevel = parseInt(args[1]);
+        let currentPermissionLevel = args[0].toLowerCase();
+        const newPermissionLevelName = args[1].toLowerCase();
+        let newPermissionLevel = args[1].toLowerCase();
         
-        if (isNaN(currentPermissionLevel) || isNaN(newPermissionLevel) || currentPermissionLevel < 0 || currentPermissionLevel > 9 || newPermissionLevel < 0 || newPermissionLevel > 9) {
-            return message.reply('Veuillez spécifier des niveaux de permission valides (entre 0 et 9).');
+        if ((currentPermissionLevel !== 'owner' && currentPermissionLevel !== 'buyer' && isNaN(parseInt(currentPermissionLevel)) || currentPermissionLevel < 0 || currentPermissionLevel > 9) ||
+            (newPermissionLevel !== 'owner' && newPermissionLevel !== 'buyer' && isNaN(parseInt(newPermissionLevel)) || newPermissionLevel < 0 || newPermissionLevel > 9)) {
+            return message.reply('Veuillez spécifier des niveaux de permission valides (entre 0 et 9) ou les mots "owner" ou "buyer".');
         }
 
-        const db = new sqlite3.Database('myDatabase.db');
+
         let permissions = await new Promise((resolve, reject) => {
             db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                 if (err) {
@@ -39,10 +40,13 @@ module.exports = {
         if (!permissions.permissions) {
             permissions.permissions = {};
         }
-
-        // Parcourir toutes les commandes et mettre à jour le niveau de permission
+        if(args[1] === "owner") newPermissionLevel = 10; 
+        if(args[1] === "buyer") newPermissionLevel = 11; 
+        if(args[0] === "owner") currentPermissionLevel = 10; 
+        if(args[0] === "buyer") currentPermissionLevel = 11; 
         for (const commandName in permissions.permissions) {
-            if (permissions.permissions[commandName] === currentPermissionLevel) {
+
+            if (permissions.permissions[commandName] === currentPermissionLevel && !unchangeableCommands.includes(commandName)) {
                  permissions.permissions[commandName] = newPermissionLevel;
                 }
             }
@@ -53,6 +57,6 @@ module.exports = {
             }
         });
 
-        message.reply(`Le niveau de permission de toutes les commandes ayant le niveau ${currentPermissionLevel} a été changé à ${newPermissionLevel}.`);
+        message.reply(`Le niveau de permission de toutes les commandes ayant le niveau \`${args[0]}\` a été changé à \`${newPermissionLevelName}\`.`);
     },
 };

commands/gestion/create.js

@@ -5,7 +5,7 @@ module.exports = {
     aliases: ['createemoji', 'create-emoji', 'create-emojis', 'emoji-create', 'emojicreate'],
     description: 'Crée un emoji',
     category: 'gestion',
-
+    utilisation: 'create <emojie>',
     async execute(message, args, client) {
         if (!args.length) {
             return message.channel.send({ content: "Veuillez spécifier un émoji." });

commands/gestion/embed.js

@@ -39,7 +39,7 @@ module.exports = {
         let msg = await message.channel.send({ embeds: [embed], components: [embedBuilderActionRow, actionRow]})
         var collector = msg.createMessageComponentCollector({
             filter: (interaction) => interaction.user.id === message.author.id,
-            time: 150000 
+            time: 250000 
         });
         
     
@@ -208,7 +208,14 @@ if(i.values[0] == "embedfooter") {
             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]})
+                if (channel && channel.guild.id === message.guild.id) {
+                    channel.send({ embeds: [embed]});
+                    message.channel.send("L'embed a bien été envoyé dans le salon " + `${channel}`)
+                    msg.edit({ embeds: [embed], components: []})
+                } else {
+                    i.channel.send("Le salon mentionné n'appartient pas à ce serveur.");
+                }
+            
             })
         }
     })

commands/gestion/log.js

@@ -0,0 +1,78 @@
+const { EventEmitterAsyncResource } = require('discord-gamecord/src/2048');
+const { AuditLogEvent, EmbedBuilder,  } = require('discord.js');
+
+module.exports = {
+    name: 'log',
+    description: 'Affiche les 10 derniers logs d\'un utilisateur',
+    async execute(message, args) {
+        // Vérifie si un utilisateur a été mentionné ou si un ID a été fourni
+        const user = message.mentions.users.first() || message.guild.members.cache.get(args[0]);
+        if (!user) {
+            return message.reply('Veuillez mentionner un utilisateur ou fournir un ID.');
+        }
+        try {
+            const fetchedLogs = await message.guild.fetchAuditLogs({ limit: 100 });
+            const userLogs = fetchedLogs.entries.filter(entry => entry.executor.id === message.author.id);
+                const embed = new EmbedBuilder()
+                    .setTitle(`Derniers logs pour l'utilisateur ${user.username}`)
+                    .setColor('#0099ff');
+                let index = 0;
+                userLogs.forEach(async (log) => {
+    const date = new Date(log.createdAt);
+    const actionText = await getActionText(log.action);
+    console.log(actionText)
+    const formattedDate = `${date.getDate()}/${date.getMonth() + 1}/${date.getFullYear()}`;
+    embed.addFields({name: `Log ${index + 1}`, value: `${actionText} - ${formattedDate}`});
+});
+
+            
+                message.channel.send({ embeds: [embed] });
+            } catch (error) {
+                console.error(error);
+                message.reply('Une erreur est survenue lors de la récupération des logs.');
+            }
+            
+            
+    },
+};
+async function getActionText(actionType) {
+    const actionTypeMapping = {
+        1: 'Ajout de bot',
+        2: 'Création de canal',
+        3: 'Suppression de canal',
+        4: 'Mise à jour de canal',
+        5: 'Ban de membre',
+        6: 'Débannissement de membre',
+        7: 'Mise à jour du serveur',
+        8: 'Création d\'intégration',
+        9: 'Suppression d\'intégration',
+        10: 'Mise à jour d\'intégration',
+        11: 'Création d\'émoji',
+        12: 'Suppression d\'émoji',
+        13: 'Mise à jour d\'émoji',
+        14: 'Création de rôle',
+        15: 'Suppression de rôle',
+        16: 'Mise à jour de rôle',
+        17: 'Création de webhook',
+        18: 'Suppression de webhook',
+        19: 'Mise à jour de webhook',
+        20: 'Création de commande d\'application',
+        21: 'Suppression de commande d\'application',
+        22: 'Mise à jour de commande d\'application',
+        23: 'Création d\'événement programmé',
+        24: 'Suppression d\'événement programmé',
+        25: 'Mise à jour d\'événement programmé',
+        26: 'Ajout d\'utilisateur à un événement programmé',
+        27: 'Retrait d\'utilisateur d\'un événement programmé',
+        28: 'Création de fil de discussion',
+        29: 'Suppression de fil de discussion',
+        30: 'Mise à jour de fil de discussion',
+        31: 'Création de sticker',
+        32: 'Suppression de sticker',
+        33: 'Mise à jour de sticker',
+        34: 'Création de fil de discussion',
+        35: 'Suppression de fil de discussion',
+        36: 'Mise à jour de fil de discussion',
+    };
+    return actionTypeMapping[actionType] || 'Action inconnue';
+}

commands/gestion/prefix.js

@@ -1,5 +1,5 @@
 const sqlite3 = require('sqlite3').verbose();
-
+const db = new sqlite3.Database('myDatabase.db');
 module.exports = {
     name: 'prefix',
     aliases: ['setprefix'],
@@ -9,14 +9,15 @@ module.exports = {
     category: 'botcontrol',
 
     async execute(message, args, client) {
-        const db = new sqlite3.Database('myDatabase.db');
         const botId = client.user.id;
         const guildId = message.guild.id;
 
         if (args.length <   1) {
             return message.reply('Veuillez spécifier un nouveau préfixe.');
         }
-
+        if (args[0].length > 4) {
+            return message.reply('Veuillez spécifier un préfixe plus court.');
+        }
         let data = await new Promise((resolve, reject) => {
             db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                 if (err) {

commands/gestion/renew.js

@@ -22,7 +22,7 @@ module.exports = {
 
             newChannel.send(`${message.author}, ce salon a été renouvelé.`);
         } else {
-            return message.reply("Je ne peux pas supprimer ce salon.");
+            return message.reply("❌ Vous ne pouvez pas renew un salon de communauté");
         }
     },
 };

commands/gestion/rolereact.js

@@ -5,11 +5,11 @@ module.exports = {
     name: 'rolereact',
     description: 'Associate an emoji with a role and add the reaction to a message',
     emote: '🎭',
-    utilisation: '+rolereact @role/id <emojie> <messageid>',
+    utilisation: 'rolereact @role/id <emojie> <messageid>',
     category: 'gestion',
     async execute(message, args, client) {
         if (args.length < 3) {
-            return message.reply('Veuillez fournir un rôle, un message ID et un emoji.');
+            return message.reply('Veuillez utiliser : \`+rolereact @role/id <emojie> <messageid>\`');
         }
 
         const role = message.mentions.roles.first() || message.guild.roles.cache.get(args[0]);

commands/invite/addinvite.js

@@ -0,0 +1,33 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'addinvite',
+    description: 'Ajoute un nombre spécifique d\'invitations à un utilisateur.',
+    emote: '📈',
+    utilisation: 'addinvite [@user/id] <nombre>',
+    category: 'invitation',
+    async execute(message, args, client) {
+        const member = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
+        if (!member) {
+            return message.reply('Veuillez mentionner un membre ou fournir un ID de membre valide.');
+        }
+        const numberToAdd = parseInt(args[1], 10);
+        if (isNaN(numberToAdd)) {
+            return message.reply('Veuillez fournir un nombre valide.');
+        }
+        addInviteCount(message.guild.id, member.id, numberToAdd);
+        message.reply(`${numberToAdd} invitations ont été ajoutées à ${member.user.tag}.`);
+    },
+};
+
+function addInviteCount(guildId, memberId, numberToAdd) {
+    db.run(`INSERT INTO invitations (guild_id, member_id, invite_count)
+            VALUES (?, ?, ?)
+            ON CONFLICT(guild_id, member_id) DO UPDATE SET invite_count = invite_count + ?`,
+            [guildId, memberId, numberToAdd, numberToAdd], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+}

commands/invite/invite.js

@@ -0,0 +1,34 @@
+const {  EmbedBuilder } = require('discord.js');
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+module.exports = {
+    name: 'invite',
+    description: 'Affiche le nombre d\'invitations d\'un utilisateur.',
+    emote: '📈',
+    utilisation: 'invite [@user/id]',
+    category: 'invitation',
+
+    async execute(message, args, client) {
+        let memberId = message.mentions.users.first()?.id ||client.users.cache.get(args[0])?.id || message.author.id;
+
+        getInviteCount(message.guild.id, memberId, (inviteCount) => {
+            const embed = new EmbedBuilder()
+                .setColor('#0099ff')
+                .setTitle('Nombre d\'invitations')
+                .setDescription(`<@${memberId}> a invité ${inviteCount} personnes.`);
+
+            message.reply({ embeds: [embed] });
+        });
+    },
+};
+
+function getInviteCount(guildId, memberId, callback) {
+    const db = new sqlite3.Database('myDatabase.db');
+    db.get(`SELECT invite_count FROM invitations WHERE guild_id = ? AND member_id = ?`,
+            [guildId, memberId], (err, row) => {
+                if (err) {
+                    return console.error(err.message);
+                }
+                callback(row ? row.invite_count : 0);
+            });
+}

commands/invite/inviteboard.js

@@ -0,0 +1,40 @@
+const { EmbedBuilder } = require('discord.js');
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'inviteboard',
+    description: 'Affiche les 10 personnes du serveur avec le plus d\'invitations.',
+    emote: '📊',
+    utilisation: 'inviteboard',
+    category: 'invitation',
+    async execute(message, args, client) {
+        db.all(`SELECT member_id, invite_count FROM invitations WHERE guild_id = ? ORDER BY invite_count DESC LIMIT 10`, [message.guild.id], (err, rows) => {
+            if (err) {
+                console.error(err.message);
+                return message.reply('Une erreur s\'est produite lors de la récupération des données d\'invitation.');
+            }
+
+            if (rows.length === 0) {
+                return message.reply('Aucune donnée d\'invitation disponible pour ce serveur.');
+            }
+
+            let leaderboard = 'Top 10 des invitations:\n';
+            rows.forEach((row, index) => {
+                const member = message.guild.members.cache.get(row.member_id);
+                if (member) {
+                    leaderboard += `${index + 1}. **${member.user.tag}**: \`${row.invite_count}\` invitations\n`;
+                }
+            });
+
+            const embed = new EmbedBuilder()
+                .setTitle('Classement des invitations')
+                .setDescription(leaderboard)
+                .setThumbnail(message.guild.iconURL({ dynamic: true, size: 1024 }))
+                .setFooter({text: `Invite leaderborder | ${client.user.username}`})
+                .setColor('#0099ff');
+
+            message.channel.send({ embeds: [embed] });
+        });
+    },
+};

commands/invite/invitereset.js

@@ -0,0 +1,44 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'invitereset',
+    aliases: ['resetinvite'],
+    description: 'Réinitialise le compteur d\'invitations pour un utilisateur ou un serveur.',
+    emote: '🔄',
+    utilisation: 'invitereset [user|guild] [@user/id]',
+    category: 'invitation',
+    async execute(message, args, client) {
+        if (args[0] === 'user') {
+            const member = message.mentions.members.first() || message.guild.members.cache.get(args[1]);
+            if (!member) {
+                return message.reply('Veuillez mentionner un membre ou fournir un ID de membre valide.');
+            }
+            resetInviteCountForUser(message.guild.id, member.id);
+            message.reply(`Le compteur d'invitations de ${member.user.tag} a été réinitialisé.`);
+        } else if (args[0] === 'guild') {
+            resetInviteCountForGuild(message.guild.id);
+            message.reply(`Le compteur d'invitations pour le serveur ${message.guild.name} a été réinitialisé.`);
+        } else {
+            message.reply('Veuillez spécifier \`user\` ou \`guild\` pour réinitialiser le compteur d\'invitations.');
+        }
+    },
+};
+
+function resetInviteCountForUser(guildId, memberId) {
+    db.run(`UPDATE invitations SET invite_count = 0 WHERE guild_id = ? AND member_id = ?`,
+            [guildId, memberId], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+}
+
+function resetInviteCountForGuild(guildId) {
+    db.run(`DELETE FROM invitations WHERE guild_id = ?`,
+            [guildId], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+}

commands/invite/removeinvite.js

@@ -0,0 +1,32 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'removeinvite',
+    description: 'Retire un nombre spécifique d\'invitations d\'un utilisateur.',
+    emote: '📈',
+    utilisation: 'removeinvite [@user/id] <nombre>',
+    category: 'invitation',
+    async execute(message, args, client) {
+        const member = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
+        if (!member) {
+            return message.reply('Veuillez mentionner un membre ou fournir un ID de membre valide.');
+        }
+        const numberToRemove = parseInt(args[1], 10);
+        if (isNaN(numberToRemove)) {
+            return message.reply('Veuillez fournir un nombre valide.');
+        }
+        removeInviteCount(message.guild.id, member.id, numberToRemove);
+        message.reply(`${numberToRemove} invitations ont été retirées de ${member.user.tag}.`);
+    },
+};
+function removeInviteCount(guildId, memberId, numberToRemove) {
+    db.run(`INSERT INTO invitations (guild_id, member_id, invite_count)
+            VALUES (?, ?, 0)
+            ON CONFLICT(guild_id, member_id) DO UPDATE SET invite_count = invite_count - ?`,
+            [guildId, memberId, numberToRemove], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+}

commands/logs/boostlog.js

@@ -0,0 +1,64 @@
+const { EmbedBuilder, ChannelType } = require('discord.js');
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'boostlog',
+    description: 'Enregistre l\'ID d\'un salon pour les logs de boosts.',
+    category: 'gestion',
+    emote: '🚀',
+    utilisation: 'boostlog [#salon/id]',
+    async execute(message, args, client) {
+        let channelId;
+        const mentionedChannel = message.mentions.channels.first();
+        
+        if (mentionedChannel) {
+            channelId = mentionedChannel.id;
+        } else if (args[0]) {
+            const channel = message.guild.channels.cache.get(args[0]);
+            if (channel && channel.type === ChannelType.GuildText) {
+                channelId = args[0];
+            } else {
+                return message.reply('Le salon spécifié est invalide ou n\'existe pas dans ce serveur.');
+            }
+        } else {
+            channelId = message.channel.id;
+        }
+        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].boostlog && data[message.guild.id].boostlog === channelId) {
+            delete data[message.guild.id].boostlog;
+            db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+            return message.reply("Le salon de boostlog a bien etait supprimé")
+        } else {
+            data[message.guild.id].boostlog = channelId;
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
+            if (err) {
+                return console.error(err.message);
+            }
+        });
+
+        const embed = new EmbedBuilder()
+            .setColor('#0099ff')
+            .setDescription(`Le salon de log de boosts a été mis à jour dans le salon <#${channelId}>`);
+        message.channel.send({ embeds: [embed] });
+    },
+};

commands/logs/channellog.js

@@ -0,0 +1,64 @@
+const { EmbedBuilder, ChannelType } = require('discord.js');
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+
+module.exports = {
+    name: 'channelog',
+    description: 'Enregistre l\'ID d\'un salon pour les logs de salons.',
+    category: 'gestion',
+    emote: '📝',
+    utilisation: 'channelog [#salon/id]',
+    async execute(message, args, client) {
+        let channelId;
+        const mentionedChannel = message.mentions.channels.first();
+        
+        if (mentionedChannel) {
+            channelId = mentionedChannel.id;
+        } else if (args[0]) {
+            const channel = message.guild.channels.cache.get(args[0]);
+            if (channel && channel.type === ChannelType.GuildText) {
+                channelId = args[0];
+            } else {
+                return message.reply('Le salon spécifié est invalide ou n\'existe pas dans ce serveur.');
+            }
+        } else {
+            channelId = message.channel.id;
+        }
+        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].channelog && data[message.guild.id].channelog === channelId) {
+            delete data[message.guild.id].channelog;
+            db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+            return message.reply("Le salon de channelog a bien etait supprimé")
+        } else {
+            data[message.guild.id].channelog = channelId;
+        }
+
+        db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
+            if (err) {
+                return console.error(err.message);
+            }
+        });
+
+        const embed = new EmbedBuilder()
+            .setColor('#0099ff')
+            .setDescription(`Le salon de log de salons a été mis à jour dans le salon <#${channelId}>`);
+        message.channel.send({ embeds: [embed] });
+    },
+};

commands/logs/messagelog.js

@@ -37,7 +37,18 @@ module.exports = {
         if (!data[message.guild.id]) {
             data[message.guild.id] = {};
         }
+
+        if (data[message.guild.id].messagelog && data[message.guild.id].messagelog === channelId) {
+            delete data[message.guild.id].messagelog;
+            db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+            return message.reply("Le salon de messagelog a bien etait supprimé")
+        } else {
             data[message.guild.id].messagelog = channelId;
+        }
 
         db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
             if (err) {

commands/logs/modlog.js

@@ -38,7 +38,18 @@ module.exports = {
         if (!data[message.guild.id]) {
             data[message.guild.id] = {};
         }
+
+        if (data[message.guild.id].modlog && data[message.guild.id].modlog === channelId) {
+            delete data[message.guild.id].modlog;
+            db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+            return message.reply("Le salon de modlog a bien etait supprimé")
+        } else {
             data[message.guild.id].modlog = channelId;
+        }
 
         db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
             if (err) {

commands/logs/presetlog.js

@@ -12,7 +12,7 @@ module.exports = {
         const sendmessage = await message.reply("\`🔄\` Les salon de log sont entrain d'etre crée...")
         const guild = message.guild;
         const categoryName = 'log';
-        const channelNames = ['modlog', 'messagelog', 'vocallog', 'rolelog', 'raidlog'];
+        const channelNames = ['modlog', 'messagelog', 'vocallog', 'rolelog', 'raidlog', 'channelog'];
         const channelTypes = [ChannelType.GuildText, ChannelType.GuildText, ChannelType.GuildText, ChannelType.GuildText, ChannelType.GuildText];
 
         let data = await new Promise((resolve, reject) => {

commands/logs/rolelog.js

@@ -1,6 +1,7 @@
 const { EmbedBuilder, ChannelType } = require('discord.js');
 const sqlite3 = require('sqlite3').verbose();
 const db = new sqlite3.Database('myDatabase.db');
+
 module.exports = {
     name: 'rolelog',
     description: 'Enregistre l\'ID d\'un salon pour les logs de rôles.',
@@ -23,6 +24,7 @@ module.exports = {
         } else {
             channelId = message.channel.id;
         }
+
         let data = await new Promise((resolve, reject) => {
             db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], (err, row) => {
                 if (err) {
@@ -36,7 +38,18 @@ module.exports = {
         if (!data[message.guild.id]) {
             data[message.guild.id] = {};
         }
+
+        if (data[message.guild.id].rolelog && data[message.guild.id].rolelog === channelId) {
+            delete data[message.guild.id].rolelog;
+            db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+            return message.reply("Le salon de rolelog a bien etait supprimé")
+        } else {
             data[message.guild.id].rolelog = channelId;
+        }
 
         db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
             if (err) {

commands/logs/setlogs.js

@@ -2,7 +2,7 @@ const { ActionRowBuilder, StringSelectMenuBuilder, EmbedBuilder } = require('dis
 const sqlite3 = require('sqlite3').verbose();
 const db = new sqlite3.Database('myDatabase.db');
 module.exports = {
-    name: 'logs',
+    name: 'setlogs',
     description: 'Affiche et configure les logs du serveur.',
     category: 'gestion',
     emote: '📝',
@@ -22,12 +22,13 @@ module.exports = {
             .setColor('#0099ff')
             .setTitle('Configuration des logs')
             .addFields(
-                { name: '📝 Logs de messages', value: data[message.guild.id]?.messagelog ? `<#${data[message.guild.id].messagelog}>` : 'Non configuré', inline: true },
-                { 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: '🛡️ raidping', value: data[message.guild.id]?.modlog ? `${data[message.guild.id].raidping}` : 'Non configuré', inline: true },
+                { name: '📝 Logs de messages', value: `**Actif**: \`${data[message.guild.id]?.messagelog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.messagelog ? `<#${data[message.guild.id].messagelog}>` : '\`Non configuré\`'}` },
+                { name: '📚 Logs de rôles', value: `**Actif**: \`${data[message.guild.id]?.rolelog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.rolelog ? `<#${data[message.guild.id].rolelog}>` : '\`Non configuré\`'}` },
+                { name: '🎙️ Logs vocaux', value: `**Actif**: \`${data[message.guild.id]?.vocallog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.vocallog ? `<#${data[message.guild.id].vocallog}>` : '\`Non configuré\`'}` },
+                { name: '🛡️ Logs de raid', value: `**Actif**: \`${data[message.guild.id]?.raidlog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.raidlog ? `<#${data[message.guild.id].raidlog}>` : '\`Non configuré\`'}` },
+                { name: '🔧 Logs de modération', value: `**Actif**: \`${data[message.guild.id]?.modlog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.modlog ? `<#${data[message.guild.id].modlog}>` : '\`Non configuré\`'}` },            
+                { name: '📝 Logs de salons', value: `**Actif**: \`${data[message.guild.id]?.channelog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.channelog ? `<#${data[message.guild.id].channelog}>` : '\`Non configuré\`'}` },
+                { name: '🚀 Logs de boosts', value: `**Actif**: \`${data[message.guild.id]?.boostlog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.boostlog ? `<#${data[message.guild.id].boostlog}>` : '\`Non configuré\`'}` },
             );
 
         const selectMenu = new StringSelectMenuBuilder()
@@ -39,7 +40,8 @@ module.exports = {
                 { label: '🎙️ Logs vocaux', value: 'vocallog', description: 'Configurer le salon de logs vocaux' },
                 { label: '🛡️ Logs de raid', value: 'raidlog', description: 'Configurer le salon de logs de raid' },
                 { label: '🔧 Logs de modération', value: 'modlog', description: 'Configurer le salon de logs de modération' },
-                { label: '🛡️ raidping', value: 'raidping', description: 'Configurer le mesage de raid' },
+                { label: '📝 Logs de salons', value: 'channelog', description: 'Configurer le salon de logs de salons' },
+                { label: '🚀 Logs de boosts', value: 'boostlog', description: 'Configurer le salon de logs de boosts' },
             ]);
 
 
@@ -99,7 +101,7 @@ module.exports = {
 
                     }
                 });
-                let data2 = await new Promise((resolve, reject) => {
+                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);
@@ -115,12 +117,13 @@ module.exports = {
                             .setColor('#0099ff')
                             .setTitle('Configuration des logs')
                             .addFields(
-                                { 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[message.guild.id]?.rolelog ? `<#${data2[message.guild.id].rolelog}>` : '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[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].raidping}` : 'Non configuré', inline: true },
+                                { name: '📝 Logs de messages', value: `**Actif**: \`${data[message.guild.id]?.messagelog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.messagelog ? `<#${data[message.guild.id].messagelog}>` : '\`Non configuré\`'}` },
+                                { name: '📚 Logs de rôles', value: `**Actif**: \`${data[message.guild.id]?.rolelog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.rolelog ? `<#${data[message.guild.id].rolelog}>` : '\`Non configuré\`'}` },
+                                { name: '🎙️ Logs vocaux', value: `**Actif**: \`${data[message.guild.id]?.vocallog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.vocallog ? `<#${data[message.guild.id].vocallog}>` : '\`Non configuré\`'}` },
+                                { name: '🛡️ Logs de raid', value: `**Actif**: \`${data[message.guild.id]?.raidlog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.raidlog ? `<#${data[message.guild.id].raidlog}>` : '\`Non configuré\`'}` },
+                                { name: '🔧 Logs de modération', value: `**Actif**: \`${data[message.guild.id]?.modlog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.modlog ? `<#${data[message.guild.id].modlog}>` : '\`Non configuré\`'}` },            
+                                { name: '📝 Logs de salons', value: `**Actif**: \`${data[message.guild.id]?.channelog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.channelog ? `<#${data[message.guild.id].channelog}>` : '\`Non configuré\`'}` },
+                                { name: '🚀 Logs de boosts', value: `**Actif**: \`${data[message.guild.id]?.boostlog ? '✅' : '❌'}\`\n **Salon: **${data[message.guild.id]?.boostlog ? `<#${data[message.guild.id].boostlog}>` : '\`Non configuré\`'}` },
                             );
                     
                   logmessage.edit({ embeds: [updatedEmbed], components: [row] });

commands/logs/vocallog.js

@@ -1,6 +1,7 @@
 const { EmbedBuilder, ChannelType } = require('discord.js');
 const sqlite3 = require('sqlite3').verbose();
 const db = new sqlite3.Database('myDatabase.db');
+
 module.exports = {
     name: 'vocallog',
     description: 'Enregistre l\'ID d\'un salon pour les logs vocaux.',
@@ -23,6 +24,7 @@ module.exports = {
         } else {
             channelId = message.channel.id;
         }
+
         let data = await new Promise((resolve, reject) => {
             db.get('SELECT value FROM gestion WHERE id = ?', [message.client.user.id], (err, row) => {
                 if (err) {
@@ -36,7 +38,18 @@ module.exports = {
         if (!data[message.guild.id]) {
             data[message.guild.id] = {};
         }
+
+        if (data[message.guild.id].vocallog && data[message.guild.id].vocallog === channelId) {
+            delete data[message.guild.id].vocallog;
+            db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
+                if (err) {
+                    return console.error(err.message);
+                }
+            });
+            return message.reply("Le salon de rolelog a bien etait supprimé")
+        } else {
             data[message.guild.id].vocallog = channelId;
+        }
 
         db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
             if (err) {

commands/moderation/addrole.js

@@ -0,0 +1,54 @@
+const { getPermissionLevel } = require('../../fonction/getPermissionLevel');
+const { PermissionsBitField } = require('discord.js');
+
+module.exports = {
+    name: 'addrole',
+    description: 'Ajoute un rôle à un utilisateur.',
+    usage: '+addrole @user/id <role>',
+    category: 'moderation',
+
+    async execute(message, args, client) {
+        const botMember = await message.guild.members.fetch(client.user.id);
+        const userMember = await message.guild.members.fetch(message.author.id);
+        if (!botMember.permissions.has(PermissionsBitField.Flags.ManageRoles)) { 
+            return message.reply("Je n'est pas la permission de pouvoir donnée des role");
+        }
+        const user = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
+        if (!user) {
+            return message.reply('Utilisateur non trouvé.');
+        }
+
+        let role;
+        if (message.mentions.roles.first()) {
+            role = message.mentions.roles.first();
+        } else if (args[1].match(/^<@&(\d+)>$/)) {
+            const roleId = args[1].match(/^<@&(\d+)>$/)[1];
+            role = message.guild.roles.cache.get(roleId);
+        } else {
+            role = message.guild.roles.cache.find(r => r.name.toLowerCase() === args[1].toLowerCase());
+        }
+
+        if (!role) {
+            return message.reply('Rôle non trouvé.');
+        }
+
+        if (role.position >= (botMember.roles.highest ? botMember.roles.highest.position : 0)) {
+            return message.reply('Je ne peux pas gérer ce rôle car il est plus haut ou égal à mon rôle le plus élevé.');
+        }
+
+        const permlevel = await getPermissionLevel(user, client);
+        if (role.permissions.has(PermissionsBitField.Flags.Administrator)&& permlevel < 10) {
+            return message.reply('Le rôle que vous demandez est dangereux.');   
+        }   
+        const roleposition = role.position;
+        const userroleposition = userMember.roles.highest.position;    
+        if (roleposition >= userroleposition && permlevel < 10) return message.reply('Vous ne pouvez pas supprimer un rôle plus élevé ou égal au vôtre.');
+
+        try {
+            await user.roles.add(role, `addrole : ${message.author.username}`);
+            message.reply(`Le rôle ${role} a été ajouté à ${user.user.tag}.`);
+        } catch (error) {
+            return message.reply('Une erreur est survenue lors de l\'ajout du rôle.');
+        }
+    },
+};

commands/moderation/badword.js

@@ -15,6 +15,7 @@ module.exports = {
         const add = args[0] === "add";
         const del = args[0] === "del";
         const list = args[0] === "list";
+        const preset = args[0] === "preset";
 
         let data = await new Promise((resolve, reject) => {
             db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
@@ -66,7 +67,28 @@ module.exports = {
                 .setDescription(data[guildId].badwords.join('\n') || 'Aucun mot interdit n\'est défini.')
                 .setFooter({text: `Mots interdits | ${client.user.username}`})
                 .setColor('#0099ff');
+            try {
             message.channel.send({ embeds: [embed] });
+            }catch (e) {
+                message.reply("Je n'ai pas pu envoyer l'embed, vérifier mes permissions.")
+            }
+        } else if (preset) {
+            const presetBadwords = [
+                "connard", "salope", "encule", "pute", "pd", "Nique", "batard", "gueule", "enfoire", "creve", "degage", "Trou du cul","raclure", "connasse", "petasse", "pute",  "suceur", "ordure", "con", "foutre", "merdeux", "pedale", "chibre"
+            ]; 
+            presetBadwords.forEach(word => {
+                if (!data[guildId].badwords.includes(word)) {
+                    data[guildId].badwords.push(word);
+                }
+            });
+            db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], (err) => {
+                if (err) {
+                    console.error(err.message);
+                    message.reply('Une erreur est survenue lors de la mise à jour de la base de données.');
+                    return;
+                }
+            });
+            message.reply('La liste prédéfinie des mots interdits a été mise à jour.')
         } else {
             message.reply('Commande invalide. Utilisez `badword add [mot]`, `badword del [mot]` ou `badword list`.');
         }

commands/moderation/ban.js

@@ -1,18 +1,21 @@
-const { EmbedBuilder, User } = require("discord.js")
-const { getPermissionLevel } = require('../../fonction/getPermissionLevel');
+const { getPermissionLevel2 } = require('../../fonction/getPermissionLevel');
 
 module.exports = {
  name: 'ban',
-  description: 'Ban a member',
+ description: 'Bannir un membre',
  emote: '🚫',
  utilisation: 'ban <@member> [reason]',
  category: 'moderation',
 
  async execute(message, args, client) {
-    const userId = message.mentions.users.first()?.id 
-      || args[0];
-
-    const user = await client.users.fetch(userId);
+    const userId = message.mentions.users.first()?.id || args[0];
+    const guildId = message.guild.id;
+    const user = await  message.guild.members.fetch(userId).catch(error => {
+      return null; 
+     });
+     const author = await message.guild.members.fetch(message.author.id).catch(error => {
+      return null; 
+     });
     if (!user) {
       return message.reply('Veuillez mentionner un utilisateur valide ou fournir un ID valide.');
     }
@@ -23,23 +26,28 @@ module.exports = {
     if (user.id === client.user.id) {
       return message.reply('Vous ne pouvez pas me ban');
     }
-    if (await getPermissionLevel(user, client) === 11) {
+    const permissionMember = await getPermissionLevel2(user, client,guildId);
+    if (permissionMember === 11) {
       return message.reply('Vous ne pouvez pas ban un membre buyer');
     }
-    if (await getPermissionLevel(user, client) === 10) {
+    if (permissionMember === 10) {
       return message.reply('Vous ne pouvez pas ban un membre owner');
     }
-    if (await getPermissionLevel(message.author, client) !== 11 || await getPermissionLevel(message.author, client) !== 10) {
-      if (await getPermissionLevel(user, client) >= await getPermissionLevel(message.author, client)) {
+    const permissionAuthor = await getPermissionLevel2(message.author, client, guildId);
+    if (permissionAuthor !== 11 && permissionAuthor !== 10) {
+      if (permissionMember >= permissionAuthor) {
         return message.reply('Vous ne pouvez pas ban un membre avec une permission égale ou supérieure à la votre');
       }
     }
-
+    if(user.roles.highest.position >= author.roles.highest.position && permissionAuthor !== 11 && permissionAuthor !== 10) {
+      return message.reply('Vous ne pouvez pas ban un membre avec un role égale ou supérieure à la votre');
+    }
     try {
-      await message.guild.members.ban(user, { reason: args.slice(1).join(' ')+` : ${message.author.tag}` || `Aucune raison spécifiée : ${message.author.tag}` });
-      message.channel.send(`L'utilisateur ${user.username} a été banni.`);
+      const reason = args.slice(1).join(' ') || `Aucune raison spécifiée : ${message.author.tag}`;
+      await message.guild.members.ban(user, { reason: `${reason} : ${message.author.tag}` });
+      message.channel.send(`L'utilisateur ${user.user.username} a été banni.`);
     } catch {
-      message.reply(`Une erreur s'est produite lors de la tentative de bannissement de ${user.username}.`);
+      message.reply(`Une erreur s'est produite lors de la tentative de bannissement de ${user.user.username}.`);
     }
  },
 };

commands/moderation/baninfo.js

@@ -0,0 +1,30 @@
+const { EmbedBuilder } = require('discord.js');
+
+module.exports = {
+    name: 'baninfo',
+    description: 'Affiche les informations d\'un utilisateur bannie',
+    emote: '🚫',
+    utilisation: 'baninfo [id]',
+    category: 'gestion',
+
+    async execute(message, args, client) {
+        const userIdToCheck = args[0];
+        const bans = await message.guild.bans.fetch();
+
+        const ban = bans.find(ban => ban.user.id === userIdToCheck);
+
+        if (!ban) {
+            return message.reply('Cet utilisateur n\'est pas dans la liste des bannis.');
+        }
+        const banner = ban.executor;
+        const reason = ban.reason || 'Raison non disponible';
+        const banDate = ban.createdAt;
+
+        const embed = new EmbedBuilder()
+            .setTitle(`Informations sur l'utilisateur ${ban.user.tag}`)
+            .setDescription(`**Raison: **\`${reason}\`\n**Bannie par: **${banner ? banner.tag : 'Inconnu'}\n**Date: **${banDate}`)
+            .setColor('#0099ff');
+
+        message.channel.send({ embeds: [embed] });
+    },
+};

commands/moderation/banlist.js

@@ -9,25 +9,28 @@ module.exports = {
     async execute(message) {
         try {
             const bans = await message.guild.bans.fetch();
+            const bansArray = Array.from(bans.values()); 
             const embeds = [];
-            const maxPerPage = 10;
-            let currentPage = 0;
+            const maxPerPage = 15;
+            let index = 0; 
+
+            for (let i = 0; i < bansArray.length; i += maxPerPage) {
+                const page = bansArray.slice(i, i + maxPerPage).map((ban) => {
+                    const reason = ban.reason || 'Raison non disponible';
+                    const entry = `**${index + 1}.** ${ban.user.tag} - **Raison: **\`${reason}\``;
+                    index++; 
+                    return entry;
+                }).join('\n');
             
-            for (let i = 0; i < bans.size; i += maxPerPage) {
                 const embed = new EmbedBuilder()
                     .setTitle('Liste des utilisateurs bannis')
+                    .setDescription(page)
                     .setColor('#ff0000');
             
-                    bans.each((ban, index) => {
-                        if (index >= i && index < i + maxPerPage) {
-                            const reason = ban.reason || 'Raison non disponible';
-                            embed.addFields({ name: ban.user.tag, value: `Raison: ${reason}` });
-                        }
-                    });
-    
                 embeds.push(embed);
             }
             
+            let currentPage = 0;
 
             const row = new ActionRowBuilder()
                 .addComponents(
@@ -41,23 +44,42 @@ module.exports = {
                         .setStyle(ButtonStyle.Primary)
                 );
 
-            await message.channel.send({ embeds: [embeds[currentPage]], components: [row] });
+            const sentMessage = await message.channel.send({ embeds: [embeds[currentPage]], components: [row] });
 
             const filter = i => i.customId === 'previous' || i.customId === 'next' && i.user.id === message.author.id;
-            const collector = message.channel.createMessageComponentCollector({ filter, time: 60000 });
+            const collector = sentMessage.createMessageComponentCollector({ filter, time: 60000 });
 
             collector.on('collect', async i => {
                 if (i.customId === 'previous') {
-                    currentPage = Math.max(currentPage - 1, 0);
+                    currentPage--;
                 } else if (i.customId === 'next') {
-                    currentPage = Math.min(currentPage + 1, embeds.length - 1);
+                    currentPage++;
                 }
             
-                await i.update({ embeds: [embeds[currentPage]], components: [row] });
-            });
+                if (currentPage < 0) {
+                    currentPage = 0;
+                } else if (currentPage >= embeds.length) {
+                    currentPage = embeds.length - 1;
+                }
             
+                const newEmbed = embeds[currentPage];
+                const backButton = new ButtonBuilder()
+                    .setCustomId('previous')
+                    .setLabel('Précédent')
+                    .setStyle(ButtonStyle.Primary);
+            
+                const nextButton = new ButtonBuilder()
+                    .setCustomId('next')
+                    .setLabel('Suivant')
+                    .setStyle(ButtonStyle.Primary);
+            
+                const row = new ActionRowBuilder()
+                    .addComponents(backButton, nextButton);
+            
+                await i.update({ embeds: [newEmbed], components: [row] });
+            });
             collector.on('end', collected => {
-                message.channel.send('Navigation terminée.');
+                sentMessage.edit({ components: [] });
             });
         } catch (error) {
             console.error('Erreur lors de la récupération des utilisateurs bannis:', error);

commands/moderation/cmute.js

@@ -0,0 +1,21 @@
+const { PermissionsBitField } = require('discord.js');
+module.exports = {
+    name: 'cmute',
+    description: 'Mute un utilisateur dans un salon',
+    emote: '🔇',
+    utilisation: 'cmute <@utilisateur> ou cmute <ID>',
+    category: 'moderation',
+
+    async execute(message, args) {
+
+        const user = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
+        if (!user) {
+            return message.reply('Veuillez mentionner une utilisateur valide.');
+        }
+        if (user.id === message.author.id) {
+            return message.reply("Vous ne pouvez pas vous mute");
+        }
+        await message.channel.permissionOverwrites.edit(user, { "SendMessages": false });
+        message.reply(`${user} a bien été mute dans le salon : <#${message.channel.id}>`)
+    },
+};

commands/moderation/cunmute.js

@@ -0,0 +1,21 @@
+module.exports = {
+    name: 'cunmute',
+    description: 'Déverrouille l\'envoi de messages pour un utilisateur dans un salon',
+    emote: '🔊',
+    utilisation: 'cunmute <@utilisateur> ou cunmute <ID>',
+    category: 'moderation',
+
+    async execute(message, args) {
+
+        const user = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
+        if (!user) {
+            return message.reply('Veuillez mentionner une utilisateur valide.');
+        }
+        if (user.id === message.author.id) {
+            return message.reply("Vous ne pouvez pas vous déverrouiller vous-même");
+        }
+        await message.channel.permissionOverwrites.delete(user.id).catch(error => {
+        });
+        message.reply(`${user} a bien été déverrouillé dans le salon : <#${message.channel.id}>`)
+    },
+};

commands/moderation/delrole.js

@@ -0,0 +1,50 @@
+const { getPermissionLevel } = require('../../fonction/getPermissionLevel');
+const { PermissionsBitField } = require('discord.js');
+
+module.exports = {
+    name: 'delrole',
+    description: 'Supprime un rôle d\'un utilisateur.',
+    usage: '+delrole <@user ou ID> <@role ou ID ou nom>',
+    category: 'moderation',
+
+    async execute(message, args, client) {
+        const botMember = await message.guild.members.fetch(client.user.id);
+        const userMember = await message.guild.members.fetch(message.author.id);
+        if (!botMember.permissions.has(PermissionsBitField.Flags.ManageRoles)) { 
+            return message.reply("Je n'ai pas la permission de pouvoir supprimer des rôles");
+        }
+        const user = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
+        if (!user) {
+            return message.reply('Utilisateur non trouvé.');
+        }
+
+        let role;
+        if (message.mentions.roles.first()) {
+            role = message.mentions.roles.first();
+        } else if (args[1].match(/^<@&(\d+)>$/)) {
+            const roleId = args[1].match(/^<@&(\d+)>$/)[1];
+            role = message.guild.roles.cache.get(roleId);
+        } else {
+            role = message.guild.roles.cache.find(r => r.name.toLowerCase() === args[1].toLowerCase());
+        }
+
+        if (!role) {
+            return message.reply('Rôle non trouvé.');
+        }
+
+        if (role.position >= (botMember.roles.highest ? botMember.roles.highest.position : 0)) {
+            return message.reply('Je ne peux pas gérer ce rôle car il est plus haut ou égal à mon rôle le plus élevé.');
+        }
+
+        const permlevel = await getPermissionLevel(user, client);  
+        const roleposition = role.position;
+        const userroleposition = userMember.roles.highest.position;         
+        if (roleposition >= userroleposition && permlevel < 10) return message.reply('Vous ne pouvez pas supprimer un rôle plus élevé ou égal au vôtre.');
+        try {
+            await user.roles.remove(role, `delrole : ${message.author.username}`);
+            message.reply(`Le rôle ${role} a été supprimé de ${user.user.tag}.`);
+        } catch (error) {
+            return message.reply('Une erreur est survenue lors de la suppression du rôle.');
+        }
+    },
+};

commands/moderation/kick.js

@@ -1,42 +1,53 @@
-const { EmbedBuilder, User } = require("discord.js")
-const { getPermissionLevel } = require('../../fonction/getPermissionLevel');
+const { getPermissionLevel2 } = require('../../fonction/getPermissionLevel');
 
 module.exports = {
     name: 'kick',
-  aliases: ['expulse'],
-  description: 'Kick a member',
+    description: 'Expluser un membre',
     emote: '🚫',
     utilisation: 'kick <@member> [reason]',
     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');
+        const userId = message.mentions.users.first()?.id || args[0];
+        const guildId = message.guild.id;
+        const user = await message.guild.members.fetch(userId).catch(error => {
+            return null; 
+        });
+        const author = await message.guild.members.fetch(message.author.id).catch(error => {
+            return null; 
+        });
+        if (!user) {
+            return message.reply('Veuillez mentionner un utilisateur valide ou fournir un ID valide.');
         }
-    if (member.id === message.author.id) {
+
+        if (user.id === message.author.id) {
             return message.reply('Vous ne pouvez pas vous kick vous même');
         }
-    if (member.id === client.user.id) {
+        if (user.id === client.user.id) {
             return message.reply('Vous ne pouvez pas me kick');
         }
-    if (await getPermissionLevel(member, client) === 11) {
+        const permissionMember = await getPermissionLevel2(user, client, guildId);
+        if (permissionMember === 11) {
             return message.reply('Vous ne pouvez pas kick un membre buyer');
         }
-    if (await getPermissionLevel(member, client) === 10) {
+        if (permissionMember === 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)) {
+        const permissionAuthor = await getPermissionLevel2(message.author, client, guildId);
+        if (permissionAuthor !== 11 && permissionAuthor !== 10) {
+            if (permissionMember >= permissionAuthor) {
                 return message.reply('Vous ne pouvez pas kick un membre avec une permission égale ou supérieure à la votre');
             }
         }
-    
-    member.kick(`${reason} : ${message.author.tag}`).then(() => {
-      message.reply(`${member.user.tag} a bien été kick`);
-    }).catch((err) => {
-      message.reply(`Une erreur est survenue lors du kick de ${member.user.tag}`);
-    });
+        if(user.roles.highest.position >= author.roles.highest.position && permissionAuthor !== 11 && permissionAuthor !== 10) {
+            return message.reply('Vous ne pouvez pas kick un membre avec un role égale ou supérieure à la votre');
+        }
+        try {
+            const reason = args.slice(1).join(' ') || `Aucune raison spécifiée : ${message.author.tag}`;
+            await user.kick(reason);
+            message.channel.send(`L'utilisateur ${user.user.username} a été kick.`);
+        } catch {
+            message.reply(`Une erreur s'est produite lors de la tentative de kick de ${user.user.username}.`);
+        }
     },
 };

commands/moderation/nickelreset.js

@@ -0,0 +1,20 @@
+module.exports = {
+    name: 'nickreset',
+    description: 'Réinitialise le pseudo d\'un membre à son nom d\'utilisateur réel.',
+    utilisation: 'nickreset [@member/memberID]',
+    category: 'moderation',
+    emote:'🛠️ ',
+    async execute(message, args, client) {
+        const member = message.mentions.members.first() || message.guild.members.cache.get(args[0]);
+
+        if (!member) {
+            return message.reply('Veuillez mentionner un membre ou fournir un ID de membre valide.');
+        }
+        try {
+            await member.setNickname(member.user.username);
+            message.reply(`Le pseudo de ${member.user.tag} a été réinitialisé à son nom d'utilisateur réel.`);
+        } catch (error) {
+            message.reply('Une erreur s\'est produite lors de la tentative de réinitialisation du pseudo.');
+        }
+    },
+};

commands/moderation/prison.js

@@ -72,6 +72,27 @@ module.exports = {
             }
             message.reply(reply);
         } else {
+            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[message.guild.id] = data[message.guild.id] || {};
+            data[message.guild.id].prisonlist = data[message.guild.id].prisonlist || [];
+            const userIndex = data[message.guild.id].prisonlist.indexOf(users.id);
+            if (userIndex !== -1) {
+                data[message.guild.id].prisonlist.splice(userIndex, 1); 
+                db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [message.client.user.id, JSON.stringify(data)], function(err) {
+                    if (err) {
+                        console.error(err.message);
+                        return message.reply('Une erreur est survenue lors de la mise à jour de la liste des utilisateurs en prison.');
+                    }
+                });
+            }
             message.reply(`👮 <@${users.id}> est libéré de prison`);
         }
     } else if (args[0] === "list") {
@@ -97,8 +118,6 @@ module.exports = {
         embed.addFields({ name: `${index + 1}`, value: `<@${userId}>`});
     });
 }
-
-    // Envoyer l'embed
     message.channel.send({ embeds: [embed] });
     }else {
         const users = message.mentions.users.first() || message.guild.members.cache.get(args[1])

commands/moderation/sanction.js

@@ -7,7 +7,7 @@ module.exports = {
     description: 'Afficher tous les avertissements d\'un utilisateur',
     aliases: ['sanction'],
     category: 'moderation',
-    utilisation: '+sanction @user/id',
+    utilisation: 'sanction @user/id',
 
     async execute(message, args, client) {
         const user = message.mentions.users.first() || client.users.cache.get(args[0]);

commands/moderation/unbanall.js

@@ -0,0 +1,29 @@
+module.exports = {
+    name: 'unbanall',
+    aliases: ['debannir-tous'],
+    description: 'Débannit tous les membres bannis',
+    emote: '🚫',
+    utilisation: 'unbanall ',
+    category: 'moderation',
+   
+    async execute(message, args, client) {   
+       try {
+        const sendmessage = await message.reply("Récupération de la liste des personnes bannies");
+        const reason = args.slice(1).join(' ') || 'Aucune raison spécifiée';
+         const bannedMembers = await message.guild.bans.fetch();
+         if (bannedMembers.size === 0) {
+           return sendmessage.edit('Il n\'y a aucun membre banni sur ce serveur.');
+         }
+         sendmessage.edit("Le unbanall est entrain d'etre effectué")
+         let counter = 0; 
+         for (const user of bannedMembers.values()) {
+            await message.guild.members.unban(user.user, `unbanall par ${message.author.tag} : ${reason}`);
+            counter++;
+           }
+   
+         sendmessage.edit(`Tous les membres bannis ont été débannis. Nombre de membres débannis : \`${counter}\``);
+       } catch (err) {
+         message.reply(`Une erreur est survenue lors du débannissement des membres.`);
+       }
+    },
+   };

commands/moderation/unwarn.js

@@ -5,7 +5,7 @@ module.exports = {
     name: 'unwarn',
     description: 'Supprimer un avertissement d\'un utilisateur',
     category: 'moderation',
-    utilisation: '+unwarn @user <warnid>',
+    utilisation: 'unwarn @user <warnid>',
 
     async execute(message, args, client) {
         const user = message.mentions.users.first() || client.users.cache.get(args[0]);
@@ -23,7 +23,6 @@ module.exports = {
         const warningId = parseInt(args[1]);
         if (!warningId) return message.reply("Veuillez mettre l'id du warn.");
 
-        // Supprimer l'avertissement de la base de données
         db.run('DELETE FROM warnings WHERE guildId = ? AND userId = ? AND warningId = ?', [message.guild.id, user.id, warningId], (err) => {
             if (err) {
                 console.error(err.message);

commands/moderation/warn.js

@@ -5,14 +5,13 @@ module.exports = {
     name: 'warn',
     description: 'Ajouter un avertissement à un utilisateur',
     category: 'moderation',
-    utilisation: '+warn @user <raison>',
+    utilisation: 'warn @user <raison>',
 
     async execute(message, args, client) {
         const user = message.mentions.users.first() || client.users.cache.get(args[0]);
         if (!user) return message.reply('Utilisateur non trouvé.');
         const reason = args.slice(1).join(' ') || 'pas de raison fournie';
 
-        // Récupérer le dernier warningId pour cette guilde et utilisateur
         let lastWarningId = await new Promise((resolve, reject) => {
             db.get('SELECT MAX(warningId) as lastWarningId FROM warnings WHERE guildId = ? AND userId = ?', [message.guild.id, user.id], (err, row) => {
                 if (err) {
@@ -23,10 +22,8 @@ module.exports = {
             });
         });
 
-        // Incrémenter le warningId pour le nouvel avertissement
         const newWarningId = lastWarningId + 1;
 
-        // Insérer l'avertissement dans la base de données
         db.run('INSERT INTO warnings (guildId, userId, warningId, reason, timestamp) VALUES (?, ?, ?, ?, ?)', [message.guild.id, user.id, newWarningId, reason, Date.now()], (err) => {
             if (err) {
                 console.error(err.message);

commands/owner/bl.js

@@ -1,20 +1,20 @@
 const sqlite3 = require('sqlite3').verbose();
 const { EmbedBuilder } = require('discord.js');
-
+const db = new sqlite3.Database('myDatabase.db');
 module.exports = {
     name: 'bl',
     aliases: ['blacklist', 'blacklistlist', 'bliste'],
     description: 'AJouter ou affiché la list des blacklist',
     emote: '🚫',
-    utilisation: 'bl [@user]',
+    utilisation: 'bl [@user] [raison]',
     category: 'gestion',
 
     async execute(message, args, client) {
-        const db = new sqlite3.Database('myDatabase.db');
         const botId = message.client.user.id;
-        const user = message.mentions.users.first() || (args[0] && client.users.cache.get(args[0]));
+        const userToBlacklist = message.mentions.users.first() || (args[0] && client.users.cache.get(args[0]));
+        const reason = args.slice(1).join(' ') || 'Aucune raison spécifiée';
 
-        if (user) {
+        if (userToBlacklist) {
             let data = await new Promise((resolve, reject) => {
                 db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
                     if (err) {
@@ -29,7 +29,11 @@ module.exports = {
                 data.blacklist = {};
             }
 
-            data.blacklist[user.id] = true;
+            data.blacklist[userToBlacklist.id] = {
+                reason: reason,
+                blacklistedBy: message.author.id,
+                timestamp: Math.floor(Date.now() / 1000) 
+            };
 
             db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [botId, JSON.stringify(data)], (err) => {
                 if (err) {
@@ -41,19 +45,18 @@ module.exports = {
             try {
                 if (client.guilds && client.guilds.cache) {
                     for (const guild of client.guilds.cache.values()) {
-                        const member = await guild.members.fetch(user.id).catch(() => null);
+                        const member = await guild.members.fetch(userToBlacklist.id).catch(() => null);
                         if (member && !member.banned) {
-                            await guild.members.ban(user.id, { reason: 'Blacklisted by bot owner' });
+                            await guild.members.ban(userToBlacklist.id, { reason: `Blacklisted by ${message.author.tag} for: ${reason}` });
                             successfulBans++;
                         }
                     }
                 }
             } catch (error) {
-                console.error(error);
             }
 
             // Informe l'utilisateur que l'opération a réussi
-            message.reply(`L'utilisateur <@${user.id}> a été ajouté à la blacklist et a été banni de ${successfulBans} serveurs.`);
+            message.reply(`L'utilisateur <@${userToBlacklist.id}> a été ajouté à la blacklist pour: ${reason} et a été banni de ${successfulBans} serveurs.`);
         } else {
             // Récupère les données existantes de la base de données
             let data = await new Promise((resolve, reject) => {
@@ -65,14 +68,11 @@ module.exports = {
                     resolve(row ? JSON.parse(row.value) : {});
                 });
             });
-
-            // Récupère la liste noire spécifique à partir des données
             const blacklist = data.blacklist || {};
 
-            // Crée un embed pour afficher la liste noire
             const embed = new EmbedBuilder()
                 .setTitle('Liste des blacklist')
-                .setDescription(Object.keys(blacklist).map(bllist => `<@${bllist}>`).join('\n') || "Aucun personne n'est blacklist")
+                .setDescription(Object.keys(blacklist).map(userId => `<@${userId}>`).join('\n') || "Aucun personne n'est blacklist")
                 .setColor('#0099ff');
 
             // Envoie l'embed dans le canal

commands/owner/blinfo.js

@@ -0,0 +1,47 @@
+const sqlite3 = require('sqlite3').verbose();
+const { EmbedBuilder } = require('discord.js');
+const db = new sqlite3.Database('myDatabase.db');
+module.exports = {
+    name: 'blinfo',
+    description: 'Affiche les informations d\'un utilisateur blacklisté',
+    emote: '🚫',
+    utilisation: 'blinfo [id]',
+    category: 'gestion',
+
+    async execute(message, args, client) {
+        const botId = message.client.user.id;
+        const userIdToCheck = args[0];
+
+        if (!userIdToCheck) {
+            return message.reply('Veuillez fournir un identifiant d\'utilisateur.');
+        }
+
+        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) : {});
+            });
+        });
+
+        const blacklist = data.blacklist || {};
+        const userInfo = blacklist[userIdToCheck];
+
+        if (!userInfo) {
+            return message.reply('Cet utilisateur n\'est pas dans la liste noire.');
+        }
+        const user = await client.users.fetch(userIdToCheck).catch(() => null);
+        if (!user) {
+            return message.reply('Utilisateur introuvable.');
+        }
+
+        const embed = new EmbedBuilder()
+            .setTitle(`Informations sur l'utilisateur ${user.username}`)
+            .setDescription(`**Raison: **\`${userInfo.reason}\`\n**Blacklisté par: **<@${userInfo.blacklistedBy}>\n**Date: **<t:${userInfo.timestamp}:R>`)
+            .setColor('#0099ff');
+
+        message.channel.send({ embeds: [embed] });
+    },
+};

commands/owner/version.js

@@ -0,0 +1,119 @@
+const sqlite3 = require('sqlite3').verbose();
+const { EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
+const paginationEmbed = require('discordjs-button-pagination');
+
+module.exports = {
+    name: 'version',
+    description: 'Affiche la version du bot',
+    emote: '📝',
+    utilisation: 'version',
+    category: 'gestion',
+
+    async execute(message, args, client) {
+        const db = new sqlite3.Database('myDatabase.db');
+        const botId = message.client.user.id;
+
+        let versionData = await new Promise((resolve, reject) => {
+            db.get('SELECT value FROM master WHERE id = ?', ['botVersion'], (err, row) => {
+                if (err) {
+                    console.error(err.message);
+                    reject(err);
+                }
+                resolve(row ? row.value : 'Version non trouvée');
+            });
+        });
+
+
+        const button = new ButtonBuilder()
+            .setCustomId('changelog')
+            .setLabel('Changelog')
+            .setStyle(ButtonStyle.Primary)
+            .setEmoji('📌');
+
+
+        const row = new ActionRowBuilder()
+            .addComponents(button);
+
+        const embed = new EmbedBuilder()
+            .setTitle('Version du bot')
+            .setDescription(`La version actuelle du bot est : ${versionData}`)
+            .setColor('#0099ff');
+            message.channel.send({ embeds: [embed], components: [row] });
+            const filter = i => i.customId === 'changelog' && i.user.id === message.author.id;
+            const collector = message.channel.createMessageComponentCollector({ filter, time: 15000 });
+        
+            collector.on('collect', async i => {
+                if (i.customId === 'changelog') {
+                    let changelogs = await new Promise((resolve, reject) => {
+                        db.get('SELECT value FROM master WHERE id = ?', ["changelogGestion"], (err, row) => {
+                            if (err) {
+                                console.error(err.message);
+                                reject(err);
+                            }
+                            resolve(row ? JSON.parse(row.value) : []);
+                        });
+                    });
+        
+                    if (changelogs.length === 0) {
+                        const noChangeLogEmbed = new EmbedBuilder()
+                            .setTitle('Aucun changement récent')
+                            .setDescription('Il n\'y a aucun changement récent à afficher.')
+                            .setColor('#0099ff');
+                        return i.reply({ embeds: [noChangeLogEmbed], ephemeral: true  });
+                    } else {
+                        const embeds = changelogs.map((log, index) => {
+                            const embed = new EmbedBuilder()
+                                .setTitle(new Date(log.timestamp).toLocaleDateString())
+                                .setDescription(log.text)
+                                .setColor('#0099ff');
+                            return embed;
+                        });
+                    sendPaginatedEmbeds(i, embeds);
+                    }
+
+                }
+            });
+        
+        
+    },
+};
+async function sendPaginatedEmbeds(interaction, embeds, timeout = 15000) {
+    let currentPage = 0;
+
+    const row = new ActionRowBuilder()
+        .addComponents(
+            new ButtonBuilder()
+                .setCustomId('previousbtn')
+                .setLabel('Précédent')
+                .setStyle(ButtonStyle.Danger)
+                .setDisabled(currentPage === 0),
+            new ButtonBuilder()
+                .setCustomId('nextbtn')
+                .setLabel('Suivant')
+                .setStyle(ButtonStyle.Success)
+                .setDisabled(currentPage === embeds.length - 1)
+        );
+
+    const embedMessage = await interaction.reply({ embeds: [embeds[currentPage]], components: [row], fetchReply: true });
+
+    const filter = i => i.customId === 'previousbtn' || i.customId === 'nextbtn' && i.user.id === interaction.user.id;
+    const collector = embedMessage.createMessageComponentCollector({ filter, time: timeout });
+
+    collector.on('collect', async i => {
+        if (i.customId === 'previousbtn') {
+            currentPage = Math.max(currentPage - 1, 0);
+        } else if (i.customId === 'nextbtn') {
+            currentPage = Math.min(currentPage + 1, embeds.length - 1);
+        }
+
+        row.components[0].setDisabled(currentPage === 0);
+        row.components[1].setDisabled(currentPage === embeds.length - 1);
+
+        await i.update({ embeds: [embeds[currentPage]], components: [row] });
+    });
+
+    collector.on('end', collected => {
+        row.components.forEach(button => button.setDisabled(true));
+        interaction.editReply({ components: [row] });
+    });
+}

commands/owner/wl.js

@@ -31,7 +31,7 @@ module.exports = {
             const embed = new EmbedBuilder()
                 .setTitle('Liste blanche')
                 .setDescription(Object.keys(whitelist).map(id => `<@${id}>`).join('\n') || 'Aucun utilisateur sur la liste blanche')
-                .setFooter({ text: 'design by valou336', iconURL: client.user.displayAvatarURL({dynamic: true})});
+                .setFooter({ text: 'by valou336', iconURL: client.user.displayAvatarURL({dynamic: true})});
 
 
             message.channel.send({ embeds: [embed] });

commands/utils/banner.js

@@ -1,6 +1,29 @@
-const fetch = require('node-fetch');
+const axios = require('axios');
 const { EmbedBuilder } = require('discord.js');
+async function getUserBanner(user, message) {
+  try {
+      const response = await axios.get(`https://discord.com/api/users/${user.id}`, {
+          headers: {
+              Authorization: `Bot ${message.client.token}`
+          }
+      });
 
+      const data = response.data;
+
+      if (!data.banner) {
+          return null;
+      }
+
+      const format = data.banner.startsWith('a_') ? 'gif' : 'png';
+      const bannerURL = `https://cdn.discordapp.com/banners/${user.id}/${data.banner}.${format}?size=2048`;
+
+      return bannerURL;
+  } catch (error) {
+      console.error(error);
+      message.reply('Une erreur s\'est produite lors de la récupération des données de l\'utilisateur.');
+      return null;
+  }
+}
 module.exports = {
   name: 'banner',
   aliases: ['bannière', 'banniere'],
@@ -11,26 +34,15 @@ module.exports = {
 
   async execute(message, args, client) {
     const user = message.mentions.users.first() || message.author;
+    const bannerURL = await getUserBanner(user, message);
 
-    const response = await fetch(`https://discord.com/api/users/${user.id}`, {
-      method: 'GET',
-      headers: {
-        Authorization: `Bot ${message.client.token}`
-      }
-    });
-    const data = await response.json();
-
-    if (!data.banner) {
+    if (!bannerURL) {
         return message.reply('Cet utilisateur n\'a pas de bannière.');
     }
 
-    const format = data.banner.startsWith('a_') ? 'gif' : 'png';
-
-    const bannerURL = `https://cdn.discordapp.com/banners/${user.id}/${data.banner}.${format}?size=2048`;
-
     const embed = new EmbedBuilder()
       .setTitle(`Bannière de ${user.tag}`)
-      .setImage(bannerURL)
+      .setImage(bannerURL || '')
       .setFooter({ text: `Demandé par ${message.author.tag}`, iconURL: message.author.displayAvatarURL() })
       .setTimestamp();
 

commands/utils/blague.js

@@ -0,0 +1,25 @@
+const axios = require('axios');
+const BlaguesAPI = require('blagues-api');
+const { EmbedBuilder } = require('discord.js');
+
+module.exports = {
+    name: 'blague',
+    description: 'Envoie une blague au hasard.',
+    emote: '😄',
+    utilisation: 'blague ',
+    category: 'utils',
+
+    async execute(message, args, client) {
+    const blagues = new BlaguesAPI("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoiMjcyNzI0MTA4NjQ1NDk4ODgwIiwibGltaXQiOjEwMCwia2V5Ijoib3V6cDQ2cjhkT3NlV1I1ZmlmcDNCc1pZSDBGWHJsb0lBQmtSTXpmcnpJalp3NmVidEciLCJjcmVhdGVkX2F0IjoiMjAyNC0wMy0wNVQxODowMjozOCswMDowMCIsImlhdCI6MTcwOTY2MTc1OH0.i-hNHrRXSdceVa_4ozInjVAapkK6KNRPt1PjO5z6I7g");
+    const blague = await blagues.random();
+    const question = blague.joke;
+    const reponse = blague.answer;
+    const randomColor = Math.floor(Math.random() * 16777215).toString(16);
+
+            const blagueEmbed = new EmbedBuilder()
+                .setDescription(`**${question}**\n➜ ||${reponse}||`)
+                .setColor(parseInt(randomColor, 16))
+
+            message.reply({ embeds: [blagueEmbed] });
+        },
+    };        

commands/utils/botconfig.js

@@ -1,5 +1,5 @@
 const { EmbedBuilder } = require('discord.js');
-
+const fetch = require('node-fetch');
 module.exports = {
     name: 'botconfig',
     description: 'Affiche la configuration du bot',
@@ -11,8 +11,23 @@ module.exports = {
     async execute(message, args, client) {
         const bot = client.user;
         const presenceStatus = bot.presence.status;
-        let presenceEmoji = '';
+        const axios = require('axios');
+        const response = await fetch(`https://discord.com/api/users/${bot.id}`, {
+            method: 'GET',
+            headers: {
+              Authorization: `Bot ${message.client.token}`
+            }
+          });
+          const data = await response.json();
       
+          if (!data.banner) {
+            return message.reply('Cet utilisateur n\'a pas de bannière.');
+          }
+      
+          const format = data.banner.startsWith('a_') ? 'gif' : 'png';
+      
+          const bannerURL = `https://cdn.discordapp.com/banners/${bot.id}/${data.banner}.${format}?size=2048`;
+          let presenceEmoji = '';
         switch (presenceStatus) {
             case 'online':
                 presenceEmoji = '🟢';  
@@ -36,6 +51,7 @@ module.exports = {
                 { name: 'Nom du bot', value: bot.username || 'Inconnu' },
                 { name: 'ID du bot', value: bot.id || 'Inconnu'},
                 { name: ' ', value: `[URL du profil](${bot.displayAvatarURL({ dynamic: true })})`},
+                { name: ' ', value: `[URL de la banniere](${bannerURL})`},
                 { name: 'Présence', value: `${presenceEmoji}`},
                 { name: 'Statut', value: bot.presence.activities[0] && bot.presence.activities[0].state ? bot.presence.activities[0].state : 'Aucun statut'}
             )

commands/utils/christmas.js

@@ -0,0 +1,20 @@
+module.exports = {
+    name: 'christmas',
+    description: 'Calcule le nombre de jours jusqu\'à Noël.',
+    emote: '🎄',
+    utilisation: 'christmas ',
+    category: 'game',
+
+    async execute(message, args, client) {
+        let today = new Date();
+        let xmas = new Date(today.getFullYear(), 11, 24);
+        if (today.getMonth() == 11 && today.getDate() > 24) {
+            xmas.setFullYear(xmas.getFullYear() + 1);
+        }
+        let one_day = 1000 * 60 * 60 * 24;
+        let daysleft = Math.ceil((xmas.getTime() - today.getTime()) / (one_day));
+        let days = daysleft + 1;
+
+        message.reply(`🎄・Noël\n${days} jours jusqu'à Noël`);
+    },
+};

commands/utils/films.js

@@ -28,7 +28,7 @@ module.exports = {
                 .setTitle('🎬 Films Populaires & Récents 🎥')
                 .setDescription('Voici les films populaires et les plus récents en ce moment :')
                 .setThumbnail(botUser.displayAvatarURL())
-                .setTimestamp() // Ajoute l'heure actuelle
+                .setTimestamp()
                 .setFooter({ text: 'Commande Films', iconURL:botUser.displayAvatarURL() });
             filmsEmbed.addFields({ name: 'Films Populaires', value: popularFilms.map(film => film.title).join(',') || 'Non disponible' });
             filmsEmbed.addFields({ name: 'Nouveautés au Cinéma', value: recentFilms.map(film => film.title).join(',') || 'Non disponible' });

commands/utils/halloween.js

@@ -0,0 +1,20 @@
+module.exports = {
+    name: 'halloween',
+    description: 'Calcule le nombre de jours jusqu\'à Halloween.',
+    emote: '🎃',
+    utilisation: 'halloween ',
+    category: 'game',
+
+    async execute(message, args, client) {
+        let today = new Date();
+        let halloween = new Date(today.getFullYear(), 9, 31); 
+        if (today.getMonth() > 9) {
+            halloween.setFullYear(halloween.getFullYear() + 1);
+        }
+        let one_day = 1000 * 60 * 60 * 24;
+        let daysleft = Math.ceil((halloween.getTime() - today.getTime()) / (one_day));
+        let days = daysleft + 1;
+
+        message.reply(`🎃・Halloween\n${days} jours jusqu'à Halloween`);
+    },
+};

commands/utils/help.js

@@ -17,18 +17,126 @@ module.exports = {
       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 }
+        { name: '{MemberMention}', value: `Mentionne le membre concerné (\`exemple\`: **<@${message.author.id}>**)`, inline: true },
+        { name: '{MemberName}', value: `Le nom du membre concerné (\`exemple\`: **${message.author.username}**)`, inline: true },
+        { name: '{MemberDisplayName}', value: `Le pseudo de serveur du membre concerné (\`exemple\`: **${message.member.displayName}**)`, inline: true },
+        { name: '{MemberJoinedAt}', value: `La date à laquelle le membre concerné a rejoint le serveur (\`exemple\`: **${new Date(message.member.joinedAt).toLocaleDateString('fr-FR')}**)`, inline: true },
+        { name: '{MemberID}', value: `L\'ID du membre concerné (\`exemple\`: **${message.author.id}**)`, inline: true },
+        { name: '{MemberPic}', value: `La photo de profil du membre concerné (\`exemple\`: **${message.author.displayAvatarURL({dynamic: true})}**)`, inline: true },
+        { name: '{MemberCreatedAt}', value: `La date de création du compte du membre concerné (\`exemple\`: **${new Date(message.author.createdAt).toLocaleDateString('fr-FR')}**)`, inline: true },
+        { name: '{ServerName}', value: `Le nom du serveur concerné (\`exemple\`: **${message.guild.name}**)`, inline: true },
+        { name: '{ServerMembersCount}', value: `Le nombre total de membres sur le serveur (\`exemple\`: **${message.guild.memberCount}**)`, inline: true }
        )
     return message.reply({ embeds: [embed] });   
-    }
+    } else if (args[0] === 'antiraid' ) {
+      const embed = new EmbedBuilder()
+      .setTitle("Help AntiRaid")
+      .setDescription(`
+  **AntiRaid Configuration**
+  
+  La commande \`antiraid\` permet de configurer la protection anti-raid pour votre serveur. Voici comment vous pouvez la configurer :
+  
+  **Syntaxe :**
+  \`\`\`
+  +antiraid [type] [action]
+  \`\`\`
+  
+  **Types disponibles :**
+  - \`whitelist\` : Permet de limiter l'accès aux actions anti-raid uniquement au whitelist du serveur et aux owners et buyer du bot.
+  - \`owner\` : Permet de limiter l'accès aux actions anti-raid uniquement au owners et buyer du bot.
+  - \`buyer\` : Permet de limiter l'accès aux actions anti-raid uniquement aux buyer du bot.
+  - \`off\` : Désactive la protection anti-raid.
+  
+  **Actions disponibles :**
+  - \`derank\` : Retire les rôles dangereux des utilisateurs qui tentent de déclencher un raid.
+  - \`kick\` : Expulse les utilisateurs qui tentent de déclencher un raid.
+  - \`ban\` : Bannit les utilisateurs qui tentent de déclencher un raid.
+  - \`nothing\` : Ne fait rien en réponse à un raid.
+  
+  **Exemples d'utilisation :**
+  - Pour activer la protection anti-raid avec une liste blanche : \`+antiraid whitelist derank\`
+  - Pour désactiver la protection anti-raid : \`+antiraid off\`
+  
+  Note : Assurez-vous d'avoir les permissions nécessaires pour exécuter cette commande.
+      `)
+    return message.reply({ embeds: [embed] });    
+  } else if (args[0] === 'backup') {
+    const embed = new EmbedBuilder()
+        .setTitle("Aide pour la commande Backup")
+        .setDescription(`
+    **Gestion des sauvegardes**
+    
+    La commande \`backup\` permet de créer, lister, charger ou supprimer des sauvegardes du serveur. Voici comment vous pouvez l'utiliser :
+    
+    **Syntaxe :**
+    \`\`\`
+    +backup <paramètres>
+    \`\`\`
+
+    **Paramètres disponibles :**
+    - \`create\` : Crée une sauvegarde du serveur actuel.
+    - \`list\` : Affiche la liste de toutes les sauvegardes disponibles.
+    - \`load\` : Charge une sauvegarde sur le serveur. Vous devez spécifier l'ID de la sauvegarde à charger.
+    - \`delete\` : Supprime une sauvegarde. Vous devez spécifier l'ID de la sauvegarde à supprimer.
+    
+    **Exemples d'utilisation :**
+    * Pour créer une sauvegarde : \`+backup create\`
+    * Pour afficher la liste des sauvegardes : \`+backup list\`
+    * Pour charger une sauvegarde (remplacez \`<backupId>\` par l'ID de la sauvegarde) : \`+backup load <backupId>\`
+    * Pour supprimer une sauvegarde (remplacez \`<backupId>\` par l'ID de la sauvegarde) : \`+backup delete <backupId>\`
+    
+    Note : Assurez-vous d'avoir les permissions nécessaires pour exécuter cette commande.
+    `)
+    return message.reply({ embeds: [embed] });
+} else if (args[0] === 'rolelimit') {
+  const embed = new EmbedBuilder()
+      .setTitle("Aide pour la commande RoleLimit")
+      .setDescription(`
+  **Gestion des limites de rôles**
+  
+  La commande \`rolelimit\` permet de gérer les limites de rôles pour les utilisateurs. Voici comment vous pouvez l'utiliser :
+  
+  **Syntaxe :**
+  \`\`\`
+  +rolelimit
+  \`\`\`
+  
+  **Fonctionnalités :**
+  - **Ajouter une limite de rôle :** Utilisez le bouton "Add" pour ajouter une limite à un rôle spécifique. Vous devrez mentionner le rôle ou fournir son ID et spécifier la limite.
+  - **Supprimer une limite de rôle :** Utilisez le bouton "Remove" pour supprimer une limite de rôle. Vous devrez mentionner le rôle ou fournir son ID.
+  
+  **Exemples d'utilisation :**
+  - Pour ajouter une limite de rôle : Sélectionnez le bouton "Add", mentionnez le rôle et spécifiez la limite.
+  - Pour supprimer une limite de rôle : Sélectionnez le bouton "Remove", mentionnez le rôle.
+  
+  Note : Assurez-vous d'avoir les permissions nécessaires pour exécuter cette commande.
+  `)
+  return message.reply({ embeds: [embed] });
+} else if (args[0] === 'confession') {
+  const embed = new EmbedBuilder()
+      .setTitle("Aide pour le système de confession")
+      .setDescription(`
+  **Configuration du système de confession**
+  
+  Le système de confession permet aux utilisateurs de partager leurs confessions de manière anonyme. Voici comment vous pouvez le configurer :
+  
+  **Syntaxe :**
+  \`\`\`
+  +setconfession [channel|send] [channelID|#channel]
+  \`\`\`
+  
+  **Paramètres disponibles :**
+  - \`channel\` : Définit le salon de confession pour le serveur. Vous devez spécifier l'ID du salon ou mentionner le salon.
+  - \`send\` : Envoie un embed avec un bouton pour ajouter une confession dans le salon spécifié. Vous devez spécifier l'ID du salon ou mentionner le salon.
+  
+  **Exemples d'utilisation :**
+  - Pour définir le salon de confession : \`+setconfession channel <channelID|#channel>\`
+  - Pour envoyer un embed de confession : \`+setconfession send <channelID|#channel>\`
+  
+  **Note : **Assurez-vous d'avoir les permissions nécessaires pour exécuter cette commande.
+  `)
+  return message.reply({ embeds: [embed] });
+} else {
     let data = await new Promise((resolve, reject) => {
       db.get('SELECT value FROM gestion WHERE id = ?', [botId], (err, row) => {
           if (err) {
@@ -43,7 +151,7 @@ module.exports = {
   let mainPrefix = data.prefixes && data.prefixes.main ? data.prefixes.main : defaultPrefix;
   let serverPrefix = data.prefixes && data.prefixes[guildId];
   const prefix = serverPrefix !== undefined ? serverPrefix : mainPrefix;
-    if (args[0]) {
+  if (args[0] && client.commands.has(args[0])) {
       const command = client.commands.get(args[0]);
       if (!command) {
         return message.reply(`Je n'ai pas trouvé de commande nommée "${args[0]}".`);
@@ -74,7 +182,7 @@ module.exports = {
           { name: 'Permissions', value: commandPerm ===  11 ? 'buyer' : commandPerm ===  10 ? 'owner' : `Perm level: ${commandPerm}`, inline: true },
         )
         .setTimestamp()
-        .setFooter({text: `${client.user.tag}  ©  2024`, iconURL: client.user.displayAvatarURL({dynamic: true})})
+        .setFooter({text: `By Valou336 and tuturp33`, iconURL: client.user.displayAvatarURL({dynamic: true})})
     
       return message.reply({ embeds: [embed_command] });
     }
@@ -87,8 +195,20 @@ module.exports = {
       game: [],
       gestion: [],
       utils: [],
+      invitation: [],
       other: [],
     };
+    const categoryEmojis = {
+      antiraid: '🛡️',
+      botcontrol: '🛠️',
+      moderation: '⚖️',
+      buyer: '💰',
+      game: '🎮',
+      gestion: '📝',
+      utils: '⚙️',
+      invitation: '📩',
+      other: '❓',
+     };
      
     let liste = [];
     for (const command of client.commands.values()) {
@@ -144,13 +264,13 @@ module.exports = {
       .setPlaceholder('Sélectionnez une catégorie')
       .addOptions([
         { label: 'Accueil', value: 'home' },
-        ...Object.keys(categories).map(category => ({ label: `Catégorie ${category}`, value: category })),
+        ...Object.keys(categories).map(category => ({ label: `${categoryEmojis[category]} ${category}`, value: category })),
       ]);
 
     const row = new ActionRowBuilder()
       .addComponents(menu);
+        const sentMessage = await message.reply({ embeds: [embeds[args[0]] || embeds.home], components: [row] });
 
-    const sentMessage = await message.reply({ embeds: [embeds.home], components: [row] });
 
     const filter = i => i.customId === 'help_menu' && i.user.id === message.author.id;
     const collector = sentMessage.createMessageComponentCollector({ filter, time:  60000 });
@@ -161,5 +281,6 @@ module.exports = {
     collector.on('end', () => {
       sentMessage.edit({ components: [] });
     });  
+  }
   },
 };

commands/utils/helpall.js

@@ -1,6 +1,7 @@
 const { EmbedBuilder , ButtonBuilder, ButtonStyle, ActionRowBuilder } = require('discord.js');
 const sqlite3 = require('sqlite3').verbose();
 const db = new sqlite3.Database('myDatabase.db');
+const { getPermissionLevel } = require('../../fonction/getPermissionLevel');
 module.exports = {
     name: 'helpall',
     description: 'Liste toutes les commandes disponibles par niveau de permission',
@@ -39,23 +40,39 @@ try {
         const embeds = Object.entries(commandsByPermission).map(([permissionLevel, commands]) => {
             const commandDescriptions = commands.map(commandName => {
                 const command = client.commands.get(commandName);
-                if (!command) {
+                if (!command || permissions[command.name] === "off") {
                     return null;
                 }
-                return `**${prefix}${commandName}**\n\`${command.description}\``;
+                return `* \`${prefix}${command.utilisation}\``;
             }).filter(Boolean);
         
             if (commandDescriptions.length === 0) {
                 return null;
             }
         
-            const embed = new EmbedBuilder()
-                .setTitle(`Commandes de niveau de permission ${permissionLevel}`)
-                .setColor('#0099ff');
+            const embedsForPermissionLevel = [];
+            let currentEmbedDescription = '';
+            commandDescriptions.forEach(description => {
+                if ((currentEmbedDescription + description).length <= 4096) {
+                    currentEmbedDescription += description + '\n';
+                } else {
+                    embedsForPermissionLevel.push(currentEmbedDescription);
+                    currentEmbedDescription = description + '\n';
+                }
+            });
+            if (currentEmbedDescription) {
+                embedsForPermissionLevel.push(currentEmbedDescription);
+            }
         
-            embed.setDescription(commandDescriptions.join('\n'));
+            return embedsForPermissionLevel.map(description => {
+                const embed = new EmbedBuilder()
+                .setTitle(`Commandes de niveau de permission ${permissionLevel === '0' ? "public" : permissionLevel === '10' ? "owner" : permissionLevel === '11' ? "buyer" : permissionLevel}`)
+                    .setColor('#0099ff');
+                embed.setDescription(description);
+                embed.permissionLevel = permissionLevel
                 return embed;
-        }).filter(Boolean) 
+            });
+        }).flat().filter(Boolean);
         
         if (embeds.length ===   0) {
             return message.reply("Aucune commande disponible pour ce serveur.");
@@ -81,22 +98,21 @@ try {
             filter: (interaction) => interaction.isButton() && interaction.user.id === message.author.id,
             time:   60000
         });
-
+        const userPermissionLevel = await getPermissionLevel(message.member, client);
         let currentPage =  0;
         collector.on('collect', async (interaction) => {
             await interaction.deferUpdate();
-
             if (interaction.customId === 'back') {
-                currentPage = currentPage >   0 ? --currentPage : embeds.length -   1;
+                currentPage = currentPage > 0 ? --currentPage : 0; 
             } else if (interaction.customId === 'next') {
-                currentPage = currentPage +   1 < embeds.length ? ++currentPage :   0;
+                currentPage = currentPage + 1 < embeds.length && embeds[currentPage + 1].permissionLevel <= userPermissionLevel ? ++currentPage : 0;
             }
-
             await msg.edit({ embeds: [embeds[currentPage]], components: [row] });
         });
 
         collector.on('end', ()  => msg.edit({ embeds: [embeds[currentPage]], components: [] }));
     }catch (error) {
+        console.log(error);
         return message.reply("Veuillez changer des commandes de permission pour avoir accès au helpall.");
     }
     },

commands/utils/image.js

@@ -7,7 +7,7 @@ module.exports = {
     description: "Recherche et envoie des images basées sur une requête.",
     category: 'utils',
     emote: '🔍',
-    utilisation: '+image [requête]',
+    utilisation: 'image [requête]',
     async execute(message, args, client) {
         const query = args.join(" ");
         if (!query) return message.react("❌");
@@ -25,7 +25,6 @@ module.exports = {
 
             message.channel.send({ embeds: [embed] });
         }).catch(error => {
-            console.error(error);
             message.reply('Une erreur est survenue lors de la recherche de l\'image.');
         });
 

commands/utils/memberstat.js

@@ -5,7 +5,7 @@ module.exports = {
     description: "Permet d'afficher les informations des utilisateurs du serveur.",
     category: 'utils',
     emote: '🌐',
-    utilisation: '+statserveur',
+    utilisation: 'statserveur',
     async execute(message, args, client) {
         const members = await message.guild.members.fetch();
         const totalMembers = members.size;

commands/utils/news.js

@@ -0,0 +1,56 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+const { EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
+const paginationEmbed = require('discordjs-button-pagination');
+
+module.exports = {
+   name: 'news',
+   aliases: ['changelog'],
+   description: 'Affiche tous les changements récents sur le bot',
+   category: "utils" ,
+   emote:"📌",
+   utilisation: "changelog",
+   async execute(message, args, client) {
+    let changelogs = await new Promise((resolve, reject) => {
+        db.get('SELECT value FROM master WHERE id = ?', ["changelogGestion"], (err, row) => {
+            if (err) {
+                console.error(err.message);
+                reject(err);
+            }
+            resolve(row ? JSON.parse(row.value) : []);
+        });
+    });
+
+    if (changelogs.length === 0) {
+        const noChangeLogEmbed = new EmbedBuilder()
+            .setTitle('Aucun changement récent')
+            .setDescription('Il n\'y a aucun changement récent à afficher.')
+            .setColor('#0099ff');
+        return message.channel.send({ embeds: [noChangeLogEmbed] });
+    }
+
+    const embeds = changelogs.map((log, index) => {
+        const embed = new EmbedBuilder()
+            .setTitle(new Date(log.timestamp).toLocaleDateString())
+            .setDescription(log.text)
+            .setColor('#0099ff');
+        return embed;
+    });
+
+    const backButton = new ButtonBuilder()
+        .setCustomId('previousbtn')
+        .setLabel('Précédent')
+        .setStyle(ButtonStyle.Danger);
+
+    const nextButton = new ButtonBuilder()
+        .setCustomId('nextbtn')
+        .setLabel('Suivant')
+        .setStyle(ButtonStyle.Success);
+
+    const buttonList = [backButton, nextButton];
+
+    const timeout = 15000; 
+
+    paginationEmbed(message, embeds, buttonList, timeout);
+   },
+};

commands/utils/prevname.js

@@ -1,16 +1,39 @@
 const { ActionRowBuilder, ButtonBuilder, ButtonStyle, EmbedBuilder } = require('discord.js');
 const sqlite3 = require('sqlite3').verbose();
 const db = new sqlite3.Database('myDatabase.db');
-
+const paginationEmbed = require('discordjs-button-pagination');
 module.exports = {
     name: 'prevname',
     description: 'Affiche tous les pseudos précédents et permet de les supprimer',
     category: 'utils', 
     emote: '🔍', 
     utilisation: 'prevname', 
-    async execute(message, args) {
+    async execute(message, args, client) {
         const userId = message.author.id;
+        if (args[0] === "clear") {
+            let hasPrevname = await new Promise((resolve, reject) => {
+                db.get('SELECT value FROM prevname WHERE id = ?', [userId], (err, row) => {
+                    if (err) {
+                        console.error(err.message);
+                        reject(err);
+                    }
+                    resolve(row !== undefined);
+                });
+            });
         
+            if (!hasPrevname) {
+                await message.reply({ content: "Vous n'avez aucun prevname à supprimer."});
+                return;
+            }
+        
+            db.run('DELETE FROM prevname WHERE id = ?', [userId], (err) => {
+                if (err) {
+                    console.error(err.message);
+                } else {
+                    message.reply({ content: "Vos prevname ont été correctement supprimés." });
+                }
+            });
+        }else {
             let nameChanges = await new Promise((resolve, reject) => {
                 db.get('SELECT value FROM prevname WHERE id = ?', [userId], (err, row) => {
                     if (err) {
@@ -21,23 +44,89 @@ module.exports = {
                 });
             });
 
-        let description = 'Vous n\'avez pas de pseudos précédents enregistrés.';
-        if (nameChanges.length > 0) {
-            description = nameChanges.map((change, index) => `${index + 1}. ${change.newName} - <t:${change.changeDate}:F>`).join('\n');
-        }
+            if (nameChanges.length === 0) {
                 const embed = new EmbedBuilder()
                     .setTitle('Pseudos précédents')
-            .setDescription(description)
+                    .setDescription('Vous n\'avez pas de pseudos précédents enregistrés.')
                     .setColor('#0099ff');
+                await message.reply({ embeds: [embed] });
+                return;
+            }
+
+            const embeds = [];
+            for (let i = 0; i < nameChanges.length; i += 10) {
+                const page = nameChanges.slice(i, i + 10).map((change, index) => `${index + 1}. ${change.newName} - <t:${change.changeDate}:F>`).join('\n');
+                const embed = new EmbedBuilder()
+                    .setTitle('Pseudos précédents')
+                    .setDescription(page)
+                    .setColor('#0099ff');
+                embeds.push(embed);
+            }
+
+
+            const backButton = new ButtonBuilder()
+                .setCustomId('previousbtn')
+                .setEmoji('⬅️')
+                .setStyle(ButtonStyle.Primary);
+
+            const nextButton = new ButtonBuilder()
+                .setCustomId('nextbtn')
+                .setEmoji('➡️')
+                .setStyle(ButtonStyle.Primary);
 
                 const deleteButton = new ButtonBuilder()
                 .setCustomId(`deleteprevnames_${message.author.id}`)
                 .setEmoji('🗑️')
                 .setStyle(ButtonStyle.Secondary);   
-
                 const row = new ActionRowBuilder()
-            .addComponents(deleteButton);
+                .addComponents(backButton, nextButton, deleteButton);
+                const sentMessage = await message.reply({ embeds: [embeds[0]], components: [row] });
 
-        await message.reply({ embeds: [embed], components: [row] });
+
+                const filter = i => i.user.id === message.author.id;
+                const collector = sentMessage.createMessageComponentCollector({ filter, time: 30000 });
+                collector.on('collect', async i => {
+                    if (!i.message.paginationState) {
+                        i.message.paginationState = { currentPage: 0 };
+                    }
+                
+                    if (i.customId === 'previousbtn') {
+                        i.message.paginationState.currentPage--;
+                    } else if (i.customId === 'nextbtn') {
+                        i.message.paginationState.currentPage++;
+                    }
+
+                    if (i.message.paginationState.currentPage < 0) {
+                        i.message.paginationState.currentPage = 0;
+                    } else if (i.message.paginationState.currentPage >= embeds.length) {
+                        i.message.paginationState.currentPage = embeds.length - 1;
+                    }
+                
+
+                    const newEmbed = embeds[i.message.paginationState.currentPage];
+                    const backButton = new ButtonBuilder()
+                    .setCustomId('previousbtn')
+                    .setEmoji('⬅️')
+                    .setStyle(ButtonStyle.Primary);
+    
+                const nextButton = new ButtonBuilder()
+                    .setCustomId('nextbtn')
+                    .setEmoji('➡️')
+                    .setStyle(ButtonStyle.Primary);
+                    const deleteButton = new ButtonBuilder()
+                    .setCustomId(`deleteprevnames_${message.author.id}`)
+                    .setEmoji('🗑️')
+                    .setStyle(ButtonStyle.Primary);   
+                    const row = new ActionRowBuilder()
+                    .addComponents(backButton, nextButton, deleteButton);
+                
+                    await i.update({ embeds: [newEmbed], components: [row] });
+                });
+                collector.on('end', collected => {
+                    const disabledRow = new ActionRowBuilder()
+                        .addComponents(backButton.setDisabled(true), nextButton.setDisabled(true), deleteButton);
+                    sentMessage.edit({ components: [disabledRow] });
+                });
+        }
     },
 };

commands/utils/wiki.js

@@ -3,7 +3,7 @@ const Discord = require('discord.js');
 module.exports = {
     name: 'wiki',
     description: 'Recherche un mot clé sur Wikipedia et affiche le résumé dans un embed.',
-    utilisation: '+wiki <mot clé>',
+    utilisation: 'wiki <mot clé>',
     category: 'info',
 
     async execute(message, args, client) {

events/antiraid.js/ChannelCreate.js

@@ -0,0 +1,110 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+const { Events, AuditLogEvent, PermissionsBitField, EmbedBuilder} = require('discord.js');
+const { getPermissionLevel } = require('../../fonction/getPermissionLevel');
+module.exports = {
+    name: Events.ChannelCreate,
+    async execute(channel, client) {
+        const botId = client.user.id;
+        const guildId = channel.guild.id;
+        const guild = channel.guild;
+        const fetchedLogs = await guild.fetchAuditLogs({
+            type: AuditLogEvent.ChannelCreate,
+            limit: 1,
+          });
+          
+          const firstEntry = fetchedLogs.entries.first();
+          const user = guild.members.cache.get(`${firstEntry.executor.id}`);
+          if (user.id === client.user.id) return;
+
+        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) : {});
+            });
+        });
+
+        const antichannelConfig = data[guildId]?.antichannel;
+        if (!antichannelConfig || antichannelConfig.type === 'off') {
+            return;
+        }
+        data.whitelist = data.whitelist || {}; 
+        data.whitelist[guildId] = data.whitelist[guildId] || {}; 
+        const whitelist = data.whitelist[guildId];
+        const type = antichannelConfig.type;
+        const permlevel = await getPermissionLevel(user, client)
+        try {
+        if (type === "whitelist") {
+            if (permlevel >= 10) return;
+            if (whitelist[user.id]) return;
+            await channel.delete('Anti-channel protection');
+            punish(user, antichannelConfig.action, channel.guild);
+            sendlog(user, antichannelConfig.action, channel.guild, data);
+        } else if (type === "owner") {
+            if (permlevel >= 10) return;
+            await channel.delete('Anti-channel protection');
+            punish(user, antichannelConfig.action, channel.guild);
+            sendlog(user, antichannelConfig.action, channel.guild, data);
+        } else if (type === "buyer") {
+            if (permlevel === 11) return;
+            await channel.delete('Anti-channel protection');
+            punish(user, antichannelConfig.action, channel.guild);
+            sendlog(user, antichannelConfig.action, channel.guild, data);
+        }
+    }catch(err) {
+    }
+    },
+};
+
+async function punish(user, action, guild) {
+    switch (action) {
+        case 'ban':
+            await guild.members.ban(user, { reason: 'Anti-channel protection' });
+            break;
+        case 'kick':
+            await guild.members.kick(user, 'Anti-channel protection');
+            break;
+        case 'derank':
+            const dangerousPermissions = [
+                PermissionsBitField.Flags.Administrator,
+                PermissionsBitField.Flags.ManageGuild,
+                PermissionsBitField.Flags.ManageRoles,
+                PermissionsBitField.Flags.ManageChannels,
+                PermissionsBitField.Flags.KickMembers,
+                PermissionsBitField.Flags.BanMembers,
+                PermissionsBitField.Flags.ManageWebhooks,
+                PermissionsBitField.Flags.MuteMembers,
+                PermissionsBitField.Flags.MentionEveryone,
+                PermissionsBitField.Flags.ManageEvents,
+                PermissionsBitField.Flags.ManageThreads,
+                ];
+            const member = guild.members.cache.get(user.id);
+            if (member) {
+                const rolesToRemove = member.roles.cache.filter(role => dangerousPermissions.includes(role.permissions.bitfield));
+                await member.roles.remove(rolesToRemove, 'Anti-channel protection');
+            }
+            break;
+        case 'nothing':
+            break;
+    }
+}
+async function sendlog(user, action, guild, data) {
+    if (!data[guild.id]) {
+        data[guild.id] = {};
+    }
+    const channelid = data[guild.id]?.raidlog;
+    if(channelid) {
+        const logChannel = guild.channels.cache.get(channelid);
+        if (!logChannel) return ;
+
+        const embed = new EmbedBuilder()
+        .setDescription(`L'utilisateur <@${user.id}> a créé un salon et a été \`${action}\`.`)
+        .setColor('#ADD8E6')
+        .setTimestamp();
+
+        logChannel.send({ embeds: [embed] });
+    }
+}

events/antiraid.js/ChannelDelete.js

@@ -0,0 +1,124 @@
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database('myDatabase.db');
+const { Events, AuditLogEvent, PermissionsBitField, EmbedBuilder} = require('discord.js');
+const { getPermissionLevel } = require('../../fonction/getPermissionLevel');
+module.exports = {
+    name: Events.ChannelDelete,
+    async execute(channel, client) {
+        const botId = client.user.id;
+        const guildId = channel.guild.id;
+        const guild = channel.guild;
+        const fetchedLogs = await guild.fetchAuditLogs({
+            type: AuditLogEvent.ChannelDelete,
+            limit: 1,
+          });
+          
+          const firstEntry = fetchedLogs.entries.first();
+          const user = guild.members.cache.get(`${firstEntry.executor.id}`);
+          if (user.id === client.user.id) return;
+        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) : {});
+            });
+        });
+
+        const antichannelConfig = data[guildId]?.antichannel;
+        if (!antichannelConfig || antichannelConfig.type === 'off') {
+            return;
+        }
+        data.whitelist = data.whitelist || {}; 
+        data.whitelist[guildId] = data.whitelist[guildId] || {}; 
+        const whitelist = data.whitelist[guildId];
+        const type = antichannelConfig.type;
+        const permlevel = await getPermissionLevel(user, client)
+        try {
+        if (type === "whitelist") {
+            if (permlevel >= 10) return;
+            if (whitelist[user.id]) return;
+            punish(user, antichannelConfig.action, channel.guild, channel);
+            sendlog(user, antichannelConfig.action, channel.guild, data);
+        } else if (type === "owner") {
+            if (permlevel >= 10) return;
+            punish(user, antichannelConfig.action, channel.guild, channel);
+            sendlog(user, antichannelConfig.action, channel.guild, data);
+        } else if (type === "buyer") {
+            if (permlevel === 11) return;
+            punish(user, antichannelConfig.action, channel.guild, channel);
+            sendlog(user, antichannelConfig.action, channel.guild, data);
+        }
+    }catch(err) {
+    }
+    },
+};
+
+async function punish(user, action, guild, channel) {
+
+    switch (action) {
+        case 'ban':
+            await guild.members.ban(user, { reason: 'Anti-channel protection' });
+            break;
+        case 'kick':
+            await guild.members.kick(user, 'Anti-channel protection');
+            break;
+        case 'derank':
+            const dangerousPermissions = [
+                PermissionsBitField.Flags.Administrator,
+                PermissionsBitField.Flags.ManageGuild,
+                PermissionsBitField.Flags.ManageRoles,
+                PermissionsBitField.Flags.ManageChannels,
+                PermissionsBitField.Flags.KickMembers,
+                PermissionsBitField.Flags.BanMembers,
+                PermissionsBitField.Flags.ManageWebhooks,
+                PermissionsBitField.Flags.MuteMembers,
+                PermissionsBitField.Flags.MentionEveryone,
+                PermissionsBitField.Flags.ManageEvents,
+                PermissionsBitField.Flags.ManageThreads,
+                ];
+            const member = guild.members.cache.get(user.id);
+            if (member) {
+                const rolesToRemove = member.roles.cache.filter(role => dangerousPermissions.includes(role.permissions.bitfield));
+                await member.roles.remove(rolesToRemove, 'Anti-channel protection');
+            }
+            break;
+        case 'nothing':
+            break;
+    }
+try {
+    channel.clone({
+    name: channel.name,
+    permissions: channel.permissionsOverwrites,
+    type: channel.type,
+    parent: channel.parent,
+    topic: channel.withTopic,
+    nsfw: channel.nsfw,
+    birate: channel.bitrate,
+    userLimit: channel.userLimit,
+    rateLimitPerUser: channel.rateLimitPerUser,
+    permissions: channel.withPermissions,
+    position: channel.rawPosition,
+    reason: 'Anti-channel protection',
+})
+} catch (error) {
+}
+}
+async function sendlog(user, action, guild, data) {
+    if (!data[guild.id]) {
+        data[guild.id] = {};
+    }
+    const channelid = data[guild.id]?.raidlog;
+    if(channelid) {
+        const logChannel = guild.channels.cache.get(channelid);
+        if (!logChannel) return ;
+
+        const embed = new EmbedBuilder()
+        .setDescription(`L'utilisateur <@${user.id}> a supprimée un salon et a été \`${action}\`.`)
+        .setColor('#ADD8E6')
+        .setTimestamp();
+
+        logChannel.send({ embeds: [embed] });
+    }
+}