add anti raide & warn commands

app/commands/🛡️ Modération/clearwarns.js

@@ -0,0 +1,123 @@
+const { EmbedBuilder } = require('discord.js');
+const addCommand = require('../../fonctions/addCommand');
+const db = require('../../db');
+
+module.exports = addCommand({
+  name: 'clearwarns',
+  description: 'Supprimer tous les avertissements d\'un utilisateur',
+  aliases: ['resetwarns', 'warnreset', 'warnclear'],
+  permissions: ['Administrator'],
+  botOwnerOnly: false,
+  dm: false,
+  scope: 'global',
+  slashOptions: [
+    { type: 'USER', name: 'utilisateur', description: 'L\'utilisateur dont vous voulez effacer les warns', required: true }
+  ],
+
+  executeSlash: async (client, interaction) => {
+    const user = interaction.options.getUser('utilisateur');
+    const guildId = interaction.guild.id;
+
+    try {
+      // Compter les warns avant suppression
+      const countResult = await db.getAsync(
+        "SELECT COUNT(*) as count FROM warnings WHERE guild_id = ? AND user_id = ?",
+        [guildId, user.id]
+      );
+
+      if (countResult.count === 0) {
+        return interaction.reply({
+          content: `✅ **${user.tag}** n'a aucun avertissement.`,
+          ephemeral: true
+        });
+      }
+
+      // Supprimer tous les warns
+      await new Promise((resolve, reject) => {
+        db.run(
+          "DELETE FROM warnings WHERE guild_id = ? AND user_id = ?",
+          [guildId, user.id],
+          function(err) {
+            if (err) reject(err);
+            else resolve();
+          }
+        );
+      });
+
+      const embed = new EmbedBuilder()
+        .setColor(0x57F287)
+        .setTitle('✅ Avertissements effacés')
+        .setDescription(`Tous les avertissements de **${user.tag}** ont été supprimés.`)
+        .addFields(
+          { name: '👤 Utilisateur', value: `${user}`, inline: true },
+          { name: '🗑️ Warns supprimés', value: `${countResult.count}`, inline: true },
+          { name: '👮 Par', value: `${interaction.user}`, inline: true }
+        )
+        .setTimestamp();
+
+      await interaction.reply({ embeds: [embed] });
+
+    } catch (err) {
+      console.error('Erreur clearwarns:', err);
+      return interaction.reply({
+        content: '❌ Une erreur est survenue.',
+        ephemeral: true
+      });
+    }
+  },
+
+  executePrefix: async (client, message, args) => {
+    if (args.length < 1) {
+      return message.reply('❌ Usage: `!clearwarns <@utilisateur>`');
+    }
+
+    const userId = args[0].replace(/[<@!>]/g, '');
+    const user = await client.users.fetch(userId).catch(() => null);
+    const guildId = message.guild.id;
+
+    if (!user) {
+      return message.reply('❌ Utilisateur non trouvé.');
+    }
+
+    try {
+      // Compter les warns avant suppression
+      const countResult = await db.getAsync(
+        "SELECT COUNT(*) as count FROM warnings WHERE guild_id = ? AND user_id = ?",
+        [guildId, user.id]
+      );
+
+      if (countResult.count === 0) {
+        return message.reply(`✅ **${user.tag}** n'a aucun avertissement.`);
+      }
+
+      // Supprimer tous les warns
+      await new Promise((resolve, reject) => {
+        db.run(
+          "DELETE FROM warnings WHERE guild_id = ? AND user_id = ?",
+          [guildId, user.id],
+          function(err) {
+            if (err) reject(err);
+            else resolve();
+          }
+        );
+      });
+
+      const embed = new EmbedBuilder()
+        .setColor(0x57F287)
+        .setTitle('✅ Avertissements effacés')
+        .setDescription(`Tous les avertissements de **${user.tag}** ont été supprimés.`)
+        .addFields(
+          { name: '👤 Utilisateur', value: `${user}`, inline: true },
+          { name: '🗑️ Warns supprimés', value: `${countResult.count}`, inline: true },
+          { name: '👮 Par', value: `${message.author}`, inline: true }
+        )
+        .setTimestamp();
+
+      await message.reply({ embeds: [embed] });
+
+    } catch (err) {
+      console.error('Erreur clearwarns:', err);
+      return message.reply('❌ Une erreur est survenue.');
+    }
+  }
+});

app/commands/🛡️ Modération/delwarn.js

@@ -0,0 +1,116 @@
+const { EmbedBuilder } = require('discord.js');
+const addCommand = require('../../fonctions/addCommand');
+const db = require('../../db');
+
+module.exports = addCommand({
+  name: 'delwarn',
+  description: 'Supprimer un avertissement',
+  aliases: ['removewarn', 'unwarn', 'clearwarn'],
+  permissions: ['ModerateMembers'],
+  botOwnerOnly: false,
+  dm: false,
+  scope: 'global',
+  slashOptions: [
+    { type: 'INTEGER', name: 'id', description: 'L\'ID de l\'avertissement à supprimer', required: true }
+  ],
+
+  executeSlash: async (client, interaction) => {
+    const warnId = interaction.options.getInteger('id');
+    const guildId = interaction.guild.id;
+
+    try {
+      // Vérifier que le warn existe
+      const warn = await db.getAsync(
+        "SELECT * FROM warnings WHERE id = ? AND guild_id = ?",
+        [warnId, guildId]
+      );
+
+      if (!warn) {
+        return interaction.reply({
+          content: '❌ Avertissement non trouvé.',
+          ephemeral: true
+        });
+      }
+
+      // Supprimer le warn
+      await new Promise((resolve, reject) => {
+        db.run("DELETE FROM warnings WHERE id = ?", [warnId], function(err) {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+
+      const user = await client.users.fetch(warn.user_id).catch(() => null);
+
+      const embed = new EmbedBuilder()
+        .setColor(0x57F287)
+        .setTitle('✅ Avertissement supprimé')
+        .addFields(
+          { name: '🆔 Warn ID', value: `#${warnId}`, inline: true },
+          { name: '👤 Utilisateur', value: user ? `${user.tag}` : warn.user_id, inline: true },
+          { name: '📝 Raison originale', value: warn.reason, inline: false }
+        )
+        .setTimestamp();
+
+      await interaction.reply({ embeds: [embed] });
+
+    } catch (err) {
+      console.error('Erreur delwarn:', err);
+      return interaction.reply({
+        content: '❌ Une erreur est survenue.',
+        ephemeral: true
+      });
+    }
+  },
+
+  executePrefix: async (client, message, args) => {
+    if (args.length < 1) {
+      return message.reply('❌ Usage: `!delwarn <id>`');
+    }
+
+    const warnId = parseInt(args[0]);
+    const guildId = message.guild.id;
+
+    if (isNaN(warnId)) {
+      return message.reply('❌ L\'ID doit être un nombre.');
+    }
+
+    try {
+      // Vérifier que le warn existe
+      const warn = await db.getAsync(
+        "SELECT * FROM warnings WHERE id = ? AND guild_id = ?",
+        [warnId, guildId]
+      );
+
+      if (!warn) {
+        return message.reply('❌ Avertissement non trouvé.');
+      }
+
+      // Supprimer le warn
+      await new Promise((resolve, reject) => {
+        db.run("DELETE FROM warnings WHERE id = ?", [warnId], function(err) {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
+
+      const user = await client.users.fetch(warn.user_id).catch(() => null);
+
+      const embed = new EmbedBuilder()
+        .setColor(0x57F287)
+        .setTitle('✅ Avertissement supprimé')
+        .addFields(
+          { name: '🆔 Warn ID', value: `#${warnId}`, inline: true },
+          { name: '👤 Utilisateur', value: user ? `${user.tag}` : warn.user_id, inline: true },
+          { name: '📝 Raison originale', value: warn.reason, inline: false }
+        )
+        .setTimestamp();
+
+      await message.reply({ embeds: [embed] });
+
+    } catch (err) {
+      console.error('Erreur delwarn:', err);
+      return message.reply('❌ Une erreur est survenue.');
+    }
+  }
+});

app/commands/🛡️ Modération/warn.js

@@ -0,0 +1,174 @@
+const { EmbedBuilder, PermissionFlagsBits } = require('discord.js');
+const addCommand = require('../../fonctions/addCommand');
+const db = require('../../db');
+const { checkWarningSanctions } = require('../../fonctions/antiraid');
+
+module.exports = addCommand({
+  name: 'warn',
+  description: 'Avertir un utilisateur',
+  aliases: ['avertir', 'avertissement'],
+  permissions: ['ModerateMembers'],
+  botOwnerOnly: false,
+  dm: false,
+  scope: 'global',
+  slashOptions: [
+    { type: 'USER', name: 'utilisateur', description: 'L\'utilisateur à avertir', required: true },
+    { type: 'STRING', name: 'raison', description: 'La raison de l\'avertissement', required: true }
+  ],
+
+  executeSlash: async (client, interaction) => {
+    const user = interaction.options.getUser('utilisateur');
+    const reason = interaction.options.getString('raison');
+    const moderator = interaction.user;
+    const guildId = interaction.guild.id;
+
+    // Vérifier qu'on ne peut pas warn un admin/mod
+    const member = await interaction.guild.members.fetch(user.id).catch(() => null);
+    if (member && member.permissions.has(PermissionFlagsBits.ModerateMembers)) {
+      return interaction.reply({
+        content: '❌ Vous ne pouvez pas avertir un modérateur.',
+        ephemeral: true
+      });
+    }
+
+    try {
+      // Ajouter le warn
+      const warnId = await new Promise((resolve, reject) => {
+        db.run(
+          "INSERT INTO warnings (guild_id, user_id, moderator_id, reason, source) VALUES (?, ?, ?, ?, ?)",
+          [guildId, user.id, moderator.id, reason, 'manual'],
+          function(err) {
+            if (err) reject(err);
+            else resolve(this.lastID);
+          }
+        );
+      });
+
+      // Compter les warns
+      const countResult = await db.getAsync(
+        "SELECT COUNT(*) as count FROM warnings WHERE guild_id = ? AND user_id = ?",
+        [guildId, user.id]
+      );
+
+      const embed = new EmbedBuilder()
+        .setColor(0xFFA500)
+        .setTitle('⚠️ Avertissement')
+        .setDescription(`**${user.tag}** a reçu un avertissement.`)
+        .addFields(
+          { name: '👤 Utilisateur', value: `${user}`, inline: true },
+          { name: '👮 Modérateur', value: `${moderator}`, inline: true },
+          { name: '📊 Total warns', value: `${countResult.count}`, inline: true },
+          { name: '📝 Raison', value: reason, inline: false },
+          { name: '🆔 Warn ID', value: `#${warnId}`, inline: true }
+        )
+        .setThumbnail(user.displayAvatarURL({ size: 64 }))
+        .setTimestamp();
+
+      await interaction.reply({ embeds: [embed] });
+
+      // Notifier l'utilisateur en MP
+      try {
+        const dmEmbed = new EmbedBuilder()
+          .setColor(0xFFA500)
+          .setTitle('⚠️ Vous avez reçu un avertissement')
+          .setDescription(`Vous avez été averti sur **${interaction.guild.name}**.`)
+          .addFields(
+            { name: '📝 Raison', value: reason },
+            { name: '📊 Total avertissements', value: `${countResult.count}` }
+          )
+          .setTimestamp();
+        await user.send({ embeds: [dmEmbed] });
+      } catch {}
+
+      // Vérifier les sanctions automatiques
+      await checkWarningSanctions(guildId, user.id, client);
+
+    } catch (err) {
+      console.error('Erreur warn:', err);
+      return interaction.reply({
+        content: '❌ Une erreur est survenue.',
+        ephemeral: true
+      });
+    }
+  },
+
+  executePrefix: async (client, message, args) => {
+    if (args.length < 2) {
+      return message.reply('❌ Usage: `!warn <@utilisateur> <raison>`');
+    }
+
+    const userMention = args[0];
+    const userId = userMention.replace(/[<@!>]/g, '');
+    const reason = args.slice(1).join(' ');
+    const moderator = message.author;
+    const guildId = message.guild.id;
+
+    const user = await client.users.fetch(userId).catch(() => null);
+    if (!user) {
+      return message.reply('❌ Utilisateur non trouvé.');
+    }
+
+    // Vérifier qu'on ne peut pas warn un admin/mod
+    const member = await message.guild.members.fetch(user.id).catch(() => null);
+    if (member && member.permissions.has(PermissionFlagsBits.ModerateMembers)) {
+      return message.reply('❌ Vous ne pouvez pas avertir un modérateur.');
+    }
+
+    try {
+      // Ajouter le warn
+      const warnId = await new Promise((resolve, reject) => {
+        db.run(
+          "INSERT INTO warnings (guild_id, user_id, moderator_id, reason, source) VALUES (?, ?, ?, ?, ?)",
+          [guildId, user.id, moderator.id, reason, 'manual'],
+          function(err) {
+            if (err) reject(err);
+            else resolve(this.lastID);
+          }
+        );
+      });
+
+      // Compter les warns
+      const countResult = await db.getAsync(
+        "SELECT COUNT(*) as count FROM warnings WHERE guild_id = ? AND user_id = ?",
+        [guildId, user.id]
+      );
+
+      const embed = new EmbedBuilder()
+        .setColor(0xFFA500)
+        .setTitle('⚠️ Avertissement')
+        .setDescription(`**${user.tag}** a reçu un avertissement.`)
+        .addFields(
+          { name: '👤 Utilisateur', value: `${user}`, inline: true },
+          { name: '👮 Modérateur', value: `${moderator}`, inline: true },
+          { name: '📊 Total warns', value: `${countResult.count}`, inline: true },
+          { name: '📝 Raison', value: reason, inline: false },
+          { name: '🆔 Warn ID', value: `#${warnId}`, inline: true }
+        )
+        .setThumbnail(user.displayAvatarURL({ size: 64 }))
+        .setTimestamp();
+
+      await message.reply({ embeds: [embed] });
+
+      // Notifier l'utilisateur en MP
+      try {
+        const dmEmbed = new EmbedBuilder()
+          .setColor(0xFFA500)
+          .setTitle('⚠️ Vous avez reçu un avertissement')
+          .setDescription(`Vous avez été averti sur **${message.guild.name}**.`)
+          .addFields(
+            { name: '📝 Raison', value: reason },
+            { name: '📊 Total avertissements', value: `${countResult.count}` }
+          )
+          .setTimestamp();
+        await user.send({ embeds: [dmEmbed] });
+      } catch {}
+
+      // Vérifier les sanctions automatiques
+      await checkWarningSanctions(guildId, user.id, client);
+
+    } catch (err) {
+      console.error('Erreur warn:', err);
+      return message.reply('❌ Une erreur est survenue.');
+    }
+  }
+});

app/commands/🛡️ Modération/warnings.js

@@ -0,0 +1,144 @@
+const { EmbedBuilder, PermissionFlagsBits } = require('discord.js');
+const addCommand = require('../../fonctions/addCommand');
+const db = require('../../db');
+
+module.exports = addCommand({
+  name: 'warnings',
+  description: 'Voir les avertissements d\'un utilisateur',
+  aliases: ['warns', 'warninfo', 'warnlist', 'infractions'],
+  permissions: [],
+  botOwnerOnly: false,
+  dm: false,
+  scope: 'global',
+  slashOptions: [
+    { type: 'USER', name: 'utilisateur', description: 'L\'utilisateur dont vous voulez voir les warns (par défaut: vous)', required: false }
+  ],
+
+  executeSlash: async (client, interaction) => {
+    const targetUser = interaction.options.getUser('utilisateur') || interaction.user;
+    const guildId = interaction.guild.id;
+
+    // Si l'utilisateur veut voir les warns d'un autre, il doit être modo
+    if (targetUser.id !== interaction.user.id) {
+      const member = interaction.member;
+      if (!member.permissions.has(PermissionFlagsBits.ModerateMembers)) {
+        return interaction.reply({
+          content: '❌ Vous ne pouvez voir que vos propres avertissements.',
+          ephemeral: true
+        });
+      }
+    }
+
+    try {
+      const warnings = await db.allAsync(
+        "SELECT * FROM warnings WHERE guild_id = ? AND user_id = ? ORDER BY created_at DESC LIMIT 25",
+        [guildId, targetUser.id]
+      );
+
+      if (!warnings || warnings.length === 0) {
+        return interaction.reply({
+          content: `✅ **${targetUser.tag}** n'a aucun avertissement sur ce serveur.`,
+          ephemeral: true
+        });
+      }
+
+      const embed = new EmbedBuilder()
+        .setColor(0xFFA500)
+        .setTitle(`⚠️ Avertissements de ${targetUser.tag}`)
+        .setThumbnail(targetUser.displayAvatarURL({ size: 64 }))
+        .setDescription(`Total: **${warnings.length}** avertissement(s)`)
+        .setTimestamp();
+
+      // Ajouter les 10 derniers warns
+      const recentWarns = warnings.slice(0, 10);
+      for (const warn of recentWarns) {
+        const moderator = await client.users.fetch(warn.moderator_id).catch(() => null);
+        const date = new Date(warn.created_at * 1000).toLocaleDateString('fr-FR');
+        const source = warn.source === 'manual' ? '👮 Manuel' : '🤖 Auto';
+        
+        embed.addFields({
+          name: `#${warn.id} - ${date}`,
+          value: `**Raison:** ${warn.reason}\n**Par:** ${moderator ? moderator.tag : 'Inconnu'} (${source})`,
+          inline: false
+        });
+      }
+
+      if (warnings.length > 10) {
+        embed.setFooter({ text: `Affichage des 10 derniers sur ${warnings.length} avertissements` });
+      }
+
+      await interaction.reply({ embeds: [embed], ephemeral: targetUser.id === interaction.user.id });
+
+    } catch (err) {
+      console.error('Erreur warnings:', err);
+      return interaction.reply({
+        content: '❌ Une erreur est survenue.',
+        ephemeral: true
+      });
+    }
+  },
+
+  executePrefix: async (client, message, args) => {
+    let targetUser;
+    
+    if (args.length > 0) {
+      const userId = args[0].replace(/[<@!>]/g, '');
+      targetUser = await client.users.fetch(userId).catch(() => null);
+      
+      // Si l'utilisateur veut voir les warns d'un autre, il doit être modo
+      if (targetUser && targetUser.id !== message.author.id) {
+        if (!message.member.permissions.has(PermissionFlagsBits.ModerateMembers)) {
+          return message.reply('❌ Vous ne pouvez voir que vos propres avertissements.');
+        }
+      }
+    }
+    
+    if (!targetUser) {
+      targetUser = message.author;
+    }
+
+    const guildId = message.guild.id;
+
+    try {
+      const warnings = await db.allAsync(
+        "SELECT * FROM warnings WHERE guild_id = ? AND user_id = ? ORDER BY created_at DESC LIMIT 25",
+        [guildId, targetUser.id]
+      );
+
+      if (!warnings || warnings.length === 0) {
+        return message.reply(`✅ **${targetUser.tag}** n'a aucun avertissement sur ce serveur.`);
+      }
+
+      const embed = new EmbedBuilder()
+        .setColor(0xFFA500)
+        .setTitle(`⚠️ Avertissements de ${targetUser.tag}`)
+        .setThumbnail(targetUser.displayAvatarURL({ size: 64 }))
+        .setDescription(`Total: **${warnings.length}** avertissement(s)`)
+        .setTimestamp();
+
+      // Ajouter les 10 derniers warns
+      const recentWarns = warnings.slice(0, 10);
+      for (const warn of recentWarns) {
+        const moderator = await client.users.fetch(warn.moderator_id).catch(() => null);
+        const date = new Date(warn.created_at * 1000).toLocaleDateString('fr-FR');
+        const source = warn.source === 'manual' ? '👮 Manuel' : '🤖 Auto';
+        
+        embed.addFields({
+          name: `#${warn.id} - ${date}`,
+          value: `**Raison:** ${warn.reason}\n**Par:** ${moderator ? moderator.tag : 'Inconnu'} (${source})`,
+          inline: false
+        });
+      }
+
+      if (warnings.length > 10) {
+        embed.setFooter({ text: `Affichage des 10 derniers sur ${warnings.length} avertissements` });
+      }
+
+      await message.reply({ embeds: [embed] });
+
+    } catch (err) {
+      console.error('Erreur warnings:', err);
+      return message.reply('❌ Une erreur est survenue.');
+    }
+  }
+});