✨ Upload latest state as of 2025-08-01

deno.json

···
 {
-  "tasks": {
-    "dev": "deno run --watch --env-file --allow-env --allow-read --allow-net --unstable-cron src/main.ts"
-  },
-  "imports": {
-    "@std/fs": "jsr:@std/fs",
-    "@std/path": "jsr:@std/path",
-    "discord.js": "npm:discord.js"
-  }
+	"tasks": {
+		"dev": "deno run --watch --env-file --allow-env --allow-read --allow-net --unstable-cron src/main.ts"
+	},
+	"imports": {
+		"@std/fs": "jsr:@std/fs",
+		"@std/path": "jsr:@std/path",
+		"discord.js": "npm:discord.js"
+	}
 }

src/core/client.ts

···
-import { Client, GatewayIntentBits } from "discord.js";
+import { Client, ClientOptions } from "discord.js";
 import { FeatureRegistry } from "./registry.ts";
 
 export class VoidyClient extends Client {
   public registry: FeatureRegistry;
 
-  constructor() {
-    super({
-      intents: [GatewayIntentBits.Guilds],
-    });
+  constructor(options: ClientOptions) {
+    super(options);
 
     this.registry = new FeatureRegistry(this);
   }

src/core/registry.ts

···
       if (interaction.isButton()) {
         const [featureId, buttonId] = interaction.customId.split(":");
         const feature = this.features.get(featureId);
-        const handler = feature?.buttonHandlers?.get(buttonId);
+        const buttonHandler = feature?.buttonHandlers?.get(buttonId);
 
-        if (feature && handler) {
+        if (feature && buttonHandler) {
           const context = {
             client: this.client,
             createCustomId: (id: string) => `${feature.id}:${id}`,
           };
 
-          return await handler(interaction, context);
+          return await buttonHandler(interaction, context);
         }
       }
     });

src/core/types.ts

···
 import {
   ButtonInteraction,
-  CommandInteraction,
+  ChatInputCommandInteraction,
   SlashCommandBuilder,
+  SlashCommandOptionsOnlyBuilder,
 } from "discord.js";
 import { VoidyClient } from "./client.ts";
 
 export interface Command {
-  data: SlashCommandBuilder;
+  data: SlashCommandBuilder | SlashCommandOptionsOnlyBuilder;
   execute: (
-    interaction: CommandInteraction,
+    interaction: ChatInputCommandInteraction,
     context: FeatureContext,
   ) => Promise<void>;
 }

src/features/utility/commands.ts

···
 import {
   ButtonBuilder,
   ButtonStyle,
+  ChatInputCommandInteraction,
   CommandInteraction,
   ContainerBuilder,
   MessageFlags,
···
     });
   },
 };
+
+export const uploadCommand: Command = {
+  data: new SlashCommandBuilder()
+    .setName("upload")
+    .setDescription("Uploads an image to the contest API")
+    .addAttachmentOption((option) =>
+      option
+        .setName("image")
+        .setDescription("The image to upload")
+        .setRequired(true)
+    )
+    .addIntegerOption((option) =>
+      option
+        .setName("contest_id")
+        .setDescription("The contest ID")
+        .setRequired(true)
+    )
+    .addStringOption((option) =>
+      option
+        .setName("participant_name")
+        .setDescription("The name of the participant")
+        .setRequired(true)
+    )
+    .addStringOption((option) =>
+      option
+        .setName("participant_email")
+        .setDescription("The email of the participant")
+        .setRequired(true)
+    ),
+
+  execute: async (
+    interaction: ChatInputCommandInteraction,
+    _context: FeatureContext,
+  ) => {
+    const attachment = interaction.options.getAttachment("image", true);
+    const contestId = interaction.options.getInteger("contest_id", true);
+    const participantName = interaction.options.getString(
+      "participant_name",
+      true,
+    );
+    const participantEmail = interaction.options.getString(
+      "participant_email",
+      true,
+    );
+
+    await interaction.deferReply({ ephemeral: true });
+
+    try {
+      const fileResponse = await fetch(attachment.url);
+      const fileBuffer = await fileResponse.arrayBuffer();
+
+      const form = new FormData();
+      form.append("image", new Blob([fileBuffer]));
+      form.append("contest_id", contestId.toString());
+      form.append("participant_name", participantName);
+      form.append("participant_email", participantEmail);
+
+      const res = await fetch("http://localhost:8000/api/upload-drawing", {
+        method: "POST",
+        body: form,
+      });
+
+      if (!res.ok) {
+        const error = await res.text();
+        console.log(error);
+
+        await interaction.editReply({
+          content: `❌ Upload failed, check console for details.`,
+        });
+
+        return;
+      }
+
+      const result = await res.json();
+      await interaction.editReply({
+        content: `✅ Image uploaded successfully!
+        Participant ID: ${result.participant_id ?? "(not returned)"}
+        Submission ID: ${result.submission_id ?? "(not returned)"}`,
+      });
+    } catch (err) {
+      console.error(err);
+      await interaction.editReply({
+        content: `❌ An error occurred during upload.`,
+      });
+
+      return;
+    }
+  },
+};

src/features/utility/index.ts

···
 import type { Feature } from "../../core/types.ts";
-import { pingCommand } from "./commands.ts";
+import { pingCommand, uploadCommand } from "./commands.ts";
 import { refreshButton } from "./interactions.ts";
 
 const UtilityFeature: Feature = {
   id: "utility",
   name: "Utility Commands",
 
-  commands: [pingCommand],
+  commands: [pingCommand, uploadCommand],
   buttonHandlers: new Map([
     ["refresh", refreshButton],
   ]),

src/main.ts

···
+import { GatewayIntentBits } from "discord.js";
 import { VoidyClient } from "./core/client.ts";
 
-const client = new VoidyClient();
+const client = new VoidyClient({
+  intents: [GatewayIntentBits.Guilds],
+});
+
 await client.start(Deno.env.get("BOT_TOKEN")!);