feat: add admin moderation commands for managing cases, warnings, and notes.

src/commands/admin/warn.ts

@@ -0,0 +1,131 @@
+import { createCommand } from "@/lib/utils";
+import { SlashCommandBuilder, PermissionFlagsBits, MessageFlags } from "discord.js";
+import { ModerationService } from "@/modules/moderation/moderation.service";
+import {
+    getWarnSuccessEmbed,
+    getModerationErrorEmbed,
+    getUserWarningEmbed
+} from "@/modules/moderation/moderation.view";
+import { config } from "@/lib/config";
+
+export const warn = createCommand({
+    data: new SlashCommandBuilder()
+        .setName("warn")
+        .setDescription("Issue a warning to a user")
+        .addUserOption(option =>
+            option
+                .setName("user")
+                .setDescription("The user to warn")
+                .setRequired(true)
+        )
+        .addStringOption(option =>
+            option
+                .setName("reason")
+                .setDescription("Reason for the warning")
+                .setRequired(true)
+                .setMaxLength(1000)
+        )
+        .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
+
+    execute: async (interaction) => {
+        await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+
+        try {
+            const targetUser = interaction.options.getUser("user", true);
+            const reason = interaction.options.getString("reason", true);
+
+            // Don't allow warning bots
+            if (targetUser.bot) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed("You cannot warn bots.")]
+                });
+                return;
+            }
+
+            // Don't allow self-warnings
+            if (targetUser.id === interaction.user.id) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed("You cannot warn yourself.")]
+                });
+                return;
+            }
+
+            // Create the warning case
+            const moderationCase = await ModerationService.createCase({
+                type: 'warn',
+                userId: targetUser.id,
+                username: targetUser.username,
+                moderatorId: interaction.user.id,
+                moderatorName: interaction.user.username,
+                reason,
+            });
+
+            if (!moderationCase) {
+                await interaction.editReply({
+                    embeds: [getModerationErrorEmbed("Failed to create warning case.")]
+                });
+                return;
+            }
+
+            // Get total warning count for the user
+            const warningCount = await ModerationService.getActiveWarningCount(targetUser.id);
+
+            // Send success message to moderator
+            await interaction.editReply({
+                embeds: [getWarnSuccessEmbed(moderationCase.caseId, targetUser.username, reason)]
+            });
+
+            // Try to DM the user if configured
+            if (config.moderation.cases.dmOnWarn) {
+                try {
+                    const serverName = interaction.guild?.name || 'this server';
+                    await targetUser.send({
+                        embeds: [getUserWarningEmbed(serverName, reason, moderationCase.caseId, warningCount)]
+                    });
+                } catch (error) {
+                    // Silently fail if user has DMs disabled
+                    console.log(`Could not DM warning to ${targetUser.username}: ${error}`);
+                }
+            }
+
+            // Optional: Check for auto-timeout threshold
+            if (config.moderation.cases.autoTimeoutThreshold &&
+                warningCount >= config.moderation.cases.autoTimeoutThreshold) {
+
+                try {
+                    const member = await interaction.guild?.members.fetch(targetUser.id);
+                    if (member) {
+                        // Auto-timeout for 24 hours (86400000 ms)
+                        await member.timeout(86400000, `Automatic timeout: ${warningCount} warnings`);
+
+                        // Create a timeout case
+                        await ModerationService.createCase({
+                            type: 'timeout',
+                            userId: targetUser.id,
+                            username: targetUser.username,
+                            moderatorId: interaction.client.user!.id,
+                            moderatorName: interaction.client.user!.username,
+                            reason: `Automatic timeout: reached ${warningCount} warnings`,
+                            metadata: { duration: '24h', automatic: true }
+                        });
+
+                        await interaction.followUp({
+                            embeds: [getModerationErrorEmbed(
+                                `⚠️ User has reached ${warningCount} warnings and has been automatically timed out for 24 hours.`
+                            )],
+                            flags: MessageFlags.Ephemeral
+                        });
+                    }
+                } catch (error) {
+                    console.error('Failed to auto-timeout user:', error);
+                }
+            }
+
+        } catch (error) {
+            console.error("Warn command error:", error);
+            await interaction.editReply({
+                embeds: [getModerationErrorEmbed("An error occurred while issuing the warning.")]
+            });
+        }
+    }
+});