gestion/commands/antiraid/rolelimit.js

const { ActionRowBuilder, EmbedBuilder, ButtonBuilder, ButtonStyle } = require('discord.js');
const sqlite3 = require('sqlite3').verbose();
const db = new sqlite3.Database('myDatabase.db');

module.exports = {
    name: 'rolelimit',
    description: 'Affiche et gère les rôles limités',
    emote: '🔒',
    utilisation: 'rolelimit',
    category: 'antiraid',

    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) {
                    console.error(err.message);
                    reject(err);
                }
                resolve(row ? JSON.parse(row.value) : []);
            });
        });

        if (!Array.isArray(limitedRoles)) {
            limitedRoles = [];
        }

        const embed = new EmbedBuilder()
            .setTitle('Rôles limités')
            .setDescription(limitedRoles.map(role => `<@&${role.id}>: ${role.limit}`).join('\n') || 'Aucun rôle limité.')
            .setColor('#0099ff');


        // Crée les boutons
        const addButton = new ButtonBuilder()
            .setCustomId('rolelimit_add')
            .setLabel('Add')
            .setStyle(ButtonStyle.Success);
        const removeButton = new ButtonBuilder()
            .setCustomId('rolelimit_remove')
            .setLabel('Remove')
            .setStyle(ButtonStyle.Danger);
        const row = new ActionRowBuilder()
            .addComponents(addButton, removeButton);
        const sentMessage = await message.reply({ embeds: [embed], components: [row], fetchReply: true });


        const filter = i => i.isButton() && i.customId.startsWith('rolelimit_') && i.user;
        const collector = sentMessage.createMessageComponentCollector({ filter: filter, time: 2 * 60 * 10000 + 30 * 10000 });


        collector.on('collect', async (i) => {
            if (i.customId === 'rolelimit_add') {
                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() || message.guild.roles.cache.get(collected.first().content);
                if (!role) {
                    return i.followUp('Rôle invalide.');
                }
                const questionMessage2 = await i.followUp('Quelle est la limite pour ce rôle ?');
                const limitCollected = await i.channel.awaitMessages({ filter, max: 1, time: 60000 });
                const limit = parseInt(limitCollected.first().content);
                if (isNaN(limit)) {
                    return i.followUp('Limite invalide.');
                }
                const existingRole = limitedRoles.find(r => r.id === role.id);
                if (existingRole) {
                    existingRole.limit = limit;
                } else {
                    limitedRoles.push({ id: role.id, limit });
                }
                db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [`${botId}.${guildId}.rolelimits`, JSON.stringify(limitedRoles)], (err) => {
                    if (err) {
                        console.error(err.message);
                    } else {
                        db.get('SELECT value FROM gestion WHERE id = ?', [`${botId}.${guildId}.rolelimits`], (err, row) => {
                            if (err) {
                                console.error(err.message);
                            } else {
                                limitedRoles = row ? JSON.parse(row.value) : [];
                                const updatedEmbed = new EmbedBuilder()
                                    .setTitle('Rôles limités')
                                    .setDescription(limitedRoles.map(role => `<@&${role.id}>: ${role.limit}`).join('\n') || 'Aucun rôle limité.')
                                    .setColor('#0099ff');
                                sentMessage.edit({ embeds: [updatedEmbed] });
                                try {
                                    questionMessage.delete();
                                    questionMessage2.delete();
                                    collected.first().delete(); 
                                    limitCollected.first().delete();
                                } catch (error) {
                                }
                                
                            }
                        });
                    }
                });
            } else if (i.customId === 'rolelimit_remove') {
                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() || message.guild.roles.cache.get(collected.first().content);
                if (!roleToRemove) {
                    return i.followUp('Rôle invalide.');
                }
                limitedRoles = limitedRoles.filter(role => role.id !== roleToRemove.id);
                db.run('INSERT OR REPLACE INTO gestion (id, value) VALUES (?, ?)', [`${botId}.${guildId}.rolelimits`, JSON.stringify(limitedRoles)], (err) => {
                    if (err) {
                        console.error(err.message);
                    } else {
                        db.get('SELECT value FROM gestion WHERE id = ?', [`${botId}.${guildId}.rolelimits`], (err, row) => {
                            if (err) {
                                console.error(err.message);
                            } else {
                                limitedRoles = row ? JSON.parse(row.value) : [];
                                const updatedEmbed = new EmbedBuilder()
                                    .setTitle('Rôles limités')
                                    .setDescription(limitedRoles.map(role => `<@&${role.id}>: ${role.limit}`).join('\n') || 'Aucun rôle limité.')
                                    .setColor('#0099ff');
                                sentMessage.edit({ embeds: [updatedEmbed] });
                                questionMessage.delete();
                                collected.first().delete();
                            }
                        });
                    }
                });
            }
        });

        collector.on('end', collected => {
            sentMessage.edit({ components: [] });
        });
    }
    },
};