feat: queue add command

virtual-designer · web-flow · commit aba1e36e02e9 · 2024-05-11T19:38:43.000Z
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -30,6 +30,7 @@
         "Buildable",
         "commitlint",
         "cooldown",
+        "crosspostable",
         "datetime",
         "deepmerge",
         "dmhistory",
diff --git a/TODO.md b/TODO.md
@@ -12,10 +12,10 @@
 -   NSFW.js AI model integration
 -   Reply and thread based AI chat conversation support. Storing messages in database, disk (JSON) or caching the last 100 messages in memory to send them to the AI model. Reply context will be limited to the reply and thread context will be limited to thread.
 -   Log infraction ~~creation~~/edition/deletion when using `-infraction` commands
--   `-modmsg` command
 -   Better cache management (especially for permission managers and command overwrites)
 
 ## 9.x
 
 -   Make a semaphore that blocks when a specific condition is met
 -   Listen to raw message delete event and raw message edit event for logging
+-   Template string function for parsing emoji literals and fetching them
diff --git a/src/framework/typescript/arguments/DurationArgument.ts b/src/framework/typescript/arguments/DurationArgument.ts
@@ -24,6 +24,12 @@ import Argument from "./Argument";
 import { ErrorType } from "./InvalidArgumentError";
 
 class DurationArgument extends Argument<Duration> {
+    public static readonly defaultErrors = {
+        [ErrorType.Required]: "You must specify a duration/time to perform this action!",
+        [ErrorType.InvalidType]: "You must specify a valid duration/time to perform this action.",
+        [ErrorType.InvalidRange]: "The given duration/time is out of range."
+    };
+
     public override toString(): string {
         return this.stringValue!.toString();
     }
diff --git a/src/main/typescript/commands/automation/AFKsCommand.ts b/src/main/typescript/commands/automation/AFKsCommand.ts
@@ -12,19 +12,31 @@ import {
     ChatInputCommandInteraction,
     Colors,
     ComponentType,
+    PermissionFlagsBits,
     escapeMarkdown,
-    italic,
-    PermissionFlagsBits
+    italic
 } from "discord.js";
 
 // TODO: Pagination
 class AFKsCommand extends Command {
     public override readonly name = "afks";
     public override readonly description: string = "Manage others' AFK statuses.";
-    public override readonly usage = ["[...reason: RestString]"];
+    public override readonly usage = ["<subcommand: String> [...args: Any[]]"];
     public override readonly aliases = ["manageafks"];
     public override readonly subcommands = ["list", "remove", "clear"];
     public override readonly permissions = [PermissionFlagsBits.ManageMessages];
+    public override readonly subcommandMeta = {
+        list: {
+            description: "List all users with AFK statuses."
+        },
+        remove: {
+            description: "Remove a user's AFK status.",
+            usage: ["<user: User>", "[...reason: RestString]"]
+        },
+        clear: {
+            description: "Clear all AFK statuses in this server."
+        }
+    };
 
     @Inject()
     private readonly afkService!: AFKService;
diff --git a/src/main/typescript/commands/automation/QueueAddCommand.ts b/src/main/typescript/commands/automation/QueueAddCommand.ts
@@ -0,0 +1,96 @@
+import { TakesArgument } from "@framework/arguments/ArgumentTypes";
+import DurationArgument from "@framework/arguments/DurationArgument";
+import { ErrorType } from "@framework/arguments/InvalidArgumentError";
+import RestStringArgument from "@framework/arguments/RestStringArgument";
+import { Command } from "@framework/commands/Command";
+import type Context from "@framework/commands/Context";
+import { Inject } from "@framework/container/Inject";
+import Duration from "@framework/datetime/Duration";
+import CommandExecutionQueue from "@main/queues/CommandExecutionQueue";
+import CommandManager from "@main/services/CommandManager";
+import QueueService from "@main/services/QueueService";
+import { Message, PermissionFlagsBits, inlineCode } from "discord.js";
+
+type QueueAddCommandArgs = {
+    runAfter: Duration;
+    command: string;
+};
+
+@TakesArgument<QueueAddCommandArgs>({
+    names: ["runAfter"],
+    types: [DurationArgument],
+    optional: false,
+    errorMessages: [DurationArgument.defaultErrors],
+    interactionName: "run_after"
+})
+@TakesArgument<QueueAddCommandArgs>({
+    names: ["command"],
+    types: [RestStringArgument],
+    optional: false,
+    errorMessages: [
+        {
+            [ErrorType.Required]: "You must specify a command to queue."
+        }
+    ],
+    interactionName: "command"
+})
+class QueueAddCommand extends Command {
+    public override readonly name = "queue::add";
+    public override readonly description: string = "Add a command execution queued job.";
+    public override readonly detailedDescription: string =
+        "Queues the given command to be run at a later time.";
+    public override readonly defer = true;
+    public override readonly permissions = [PermissionFlagsBits.ManageGuild];
+
+    @Inject()
+    private readonly commandManager!: CommandManager;
+
+    @Inject()
+    private readonly queueManager!: QueueService;
+
+    public override async execute(context: Context, args: QueueAddCommandArgs): Promise<void> {
+        const { command, runAfter } = args;
+        const commandName = command.slice(0, Math.max(command.indexOf(" "), command.indexOf("\n")));
+
+        if (!this.commandManager.commands.has(commandName)) {
+            return void context.error(
+                `The specified command ${inlineCode(commandName)} does not exist.`
+            );
+        }
+
+        let messageId: string;
+        let reply: Message | undefined;
+
+        if (context.isLegacy()) {
+            messageId = context.commandMessage.id;
+        } else {
+            reply = await context.reply(`${context.emoji("loading")} Creating queue job...`);
+            messageId = reply.id;
+        }
+
+        const id = await this.queueManager
+            .create(CommandExecutionQueue, {
+                data: {
+                    guildId: context.guildId,
+                    memberId: context.memberId!,
+                    messageId,
+                    channelId: context.channelId,
+                    commandString: command,
+                    fromInteraction: context.isChatInput()
+                },
+                guildId: context.guildId,
+                runsAt: new Date(Date.now() + runAfter.toMilliseconds())
+            })
+            .schedule();
+
+        const response = `${context.emoji("check")} Successfully queued the given command. The queue ID is ${inlineCode(id.toString())}.`;
+
+        if (reply) {
+            await reply.edit(response);
+        } else {
+            await context.reply(response);
+        }
+    }
+}
+
+export default QueueAddCommand;
diff --git a/src/main/typescript/commands/automation/QueueCommand.ts b/src/main/typescript/commands/automation/QueueCommand.ts
@@ -0,0 +1,85 @@
+import type { Buildable } from "@framework/commands/Command";
+import { Command } from "@framework/commands/Command";
+import { PermissionFlagsBits } from "discord.js";
+
+class QueueCommand extends Command {
+    public override readonly name = "queue";
+    public override readonly description: string = "Manage queued jobs.";
+    public override readonly detailedDescription: string = "Custom command.";
+    public override readonly defer = true;
+    public override readonly usage = ["<subcommand: String> [...args: Any[]]"];
+    public override readonly systemPermissions = [];
+    public override readonly subcommands = ["list", "cancel", "show", "add"];
+    public override readonly isolatedSubcommands = true;
+    public override readonly aliases = ["queues", "q"];
+    public override readonly permissions = [PermissionFlagsBits.ManageGuild];
+    public override readonly subcommandMeta = {
+        list: {
+            description: "List all queued jobs."
+        },
+        cancel: {
+            description: "Cancel a queued job.",
+            usage: ["<jobId: String>"]
+        },
+        show: {
+            description: "Show a queued job.",
+            usage: ["<jobId: String>"]
+        },
+        add: {
+            description: "Add a command execution job to the queue.",
+            usage: ["<runAfter: Duration> <...command: RestString[]>"]
+        }
+    };
+
+    public override build(): Buildable[] {
+        return [
+            this.buildChatInput()
+                .addSubcommand(subcommand =>
+                    subcommand.setName("list").setDescription("List all queued jobs.")
+                )
+                .addSubcommand(subcommand =>
+                    subcommand
+                        .setName("cancel")
+                        .setDescription("Cancel a queued job.")
+                        .addStringOption(option =>
+                            option
+                                .setName("id")
+                                .setDescription("The ID of the job to cancel.")
+                                .setRequired(true)
+                        )
+                )
+                .addSubcommand(subcommand =>
+                    subcommand
+                        .setName("show")
+                        .setDescription("Show a queued job.")
+                        .addStringOption(option =>
+                            option
+                                .setName("id")
+                                .setDescription("The ID of the job to show.")
+                                .setRequired(true)
+                        )
+                )
+                .addSubcommand(subcommand =>
+                    subcommand
+                        .setName("add")
+                        .setDescription("Add a command execution job to the queue.")
+                        .addStringOption(option =>
+                            option
+                                .setName("run_after")
+                                .setDescription("The duration to wait before running the command.")
+                                .setRequired(true)
+                        )
+                        .addStringOption(option =>
+                            option
+                                .setName("command")
+                                .setDescription("The command to run.")
+                                .setRequired(true)
+                        )
+                )
+        ];
+    }
+
+    public override async execute(): Promise<void> {}
+}
+
+export default QueueCommand;
diff --git a/src/main/typescript/queues/CommandExecutionQueue.ts b/src/main/typescript/queues/CommandExecutionQueue.ts
@@ -0,0 +1,137 @@
+import Queue from "@framework/queues/Queue";
+import { fetchChannel, fetchMember } from "@framework/utils/entities";
+import type {
+    MessageCreateOptions,
+    MessagePayload,
+    MessageReplyOptions,
+    Snowflake
+} from "discord.js";
+
+type CommandExecutionQueuePayload = {
+    guildId: Snowflake;
+    memberId: Snowflake;
+    messageId: Snowflake;
+    channelId: Snowflake;
+    commandString: string;
+    fromInteraction: boolean;
+};
+
+class CommandExecutionQueue extends Queue<CommandExecutionQueuePayload> {
+    public static override readonly uniqueName = "command_execution";
+
+    private cloneObject(obj: object) {
+        const clonedObj = Object.create(Object.getPrototypeOf(obj));
+
+        for (const key of Reflect.ownKeys(obj)) {
+            const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+
+            if (descriptor) {
+                Object.defineProperty(clonedObj, key, descriptor);
+            }
+        }
+
+        return clonedObj;
+    }
+
+    public async execute({
+        guildId,
+        memberId,
+        channelId,
+        commandString,
+        messageId,
+        fromInteraction
+    }: CommandExecutionQueuePayload) {
+        const prefix = this.application.getServiceByName("configManager").config[guildId]?.prefix;
+
+        if (!prefix) {
+            this.application.logger.error(`No prefix found for guild ${guildId}`);
+            return;
+        }
+
+        const guild = this.application.client.guilds.cache.get(guildId);
+
+        if (!guild) {
+            return;
+        }
+
+        const channel = await fetchChannel(guild, channelId);
+
+        if (!channel?.isTextBased()) {
+            return;
+        }
+
+        const message = await channel.messages.fetch(messageId);
+
+        if (!message) {
+            return;
+        }
+
+        const copy = this.cloneObject(message);
+
+        copy!.reply = (...args: [MessagePayload | MessageReplyOptions | string]) =>
+            message.reply(...(args as [MessageCreateOptions | string]));
+        copy!.delete = () => Promise.resolve(message!);
+        copy!.react = () =>
+            Promise.resolve(null as unknown as ReturnType<NonNullable<typeof message>["react"]>);
+
+        copy.content = `${prefix}${commandString}`;
+        copy.channelId = channel.id;
+
+        Object.defineProperty(copy, "channel", {
+            get: () => channel
+        });
+
+        Object.defineProperty(copy, "url", {
+            get: () => `https://discord.com/channels/${message.guild.id}/${channel.id}/${messageId}`
+        });
+
+        Object.defineProperty(copy, "guild", {
+            get: () => guild
+        });
+
+        Object.defineProperty(copy, "mentions", {
+            value: message.mentions,
+            enumerable: true,
+            configurable: true,
+            writable: false
+        });
+
+        if (!fromInteraction && copy.author.id !== memberId) {
+            this.application.logger.error(
+                `Invalid message author for message ${message.id} in guild ${guild.id}`
+            );
+
+            return;
+        }
+
+        const member = await fetchMember(guild, memberId);
+
+        if (!member) {
+            this.application.logger.error(
+                `Invalid member for message ${message.id} in guild ${guild.id}`
+            );
+
+            return;
+        }
+
+        copy.author = member.user;
+
+        Object.defineProperty(copy, "member", {
+            value: member,
+            enumerable: true,
+            configurable: true
+        });
+
+        if (
+            (await this.application
+                .getServiceByName("commandManager")
+                .runCommandFromMessage(copy)) === false
+        ) {
+            this.application.logger.error(
+                `Failed to run command from message ${message.id} in guild ${guild.id}`
+            );
+        }
+    }
+}
+
+export default CommandExecutionQueue;
