commands/automation/QueueAddCommand.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import { formatDistanceToNowStrict } from "date-fns";
import { EmbedBuilder, Message, PermissionsBitField, escapeMarkdown } from "discord.js";
import path from "path";
import Command, { BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import QueueEntry from "../../utils/QueueEntry";
import { stringToTimeInterval } from "../../utils/datetime";

export default class QueueAddCommand extends Command {
    public readonly name = "queue__add";
    public readonly validationRules: ValidationRule[] = [];
    public readonly aliases = ["queueadd", "addqueue", "createqueue"];
    public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
    public readonly description = "Creates a new command queue";
    public readonly since = "5.57.0";

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        const deferredMessage = await (await this.deferIfInteraction(message))?.fetch();
        const runAfterString = context.isLegacy ? context.args[0] : context.options.getString("run_after", true);

        if (!runAfterString) {
            await this.error(message, "Please specify after how much time the queue should run!");
            return;
        }

        const { error, result: runAfter } = stringToTimeInterval(runAfterString, { milliseconds: true });

        if (error) {
            await this.error(message, error);
            return;
        }

        if (context.isLegacy && !context.args[1]) {
            await this.error(message, "Please specify the command to queue!");
            return;
        }

        const commandString = context.isLegacy
            ? (message as Message).content
                  .substring(this.client.configManager.config[message.guildId!]?.prefix?.length ?? 1)
                  .trimStart()
                  .substring(context.argv[0] === "queue" ? "queue".length : 0)
                  .trimStart()
                  .substring(context.argv[0] === "queue" ? this.name.replace("queue__", "").length : context.argv[0].length)
                  .trimStart()
                  .substring(runAfterString.length)
                  .trim()
            : context.options.getString("command", true).trim();

        let commandName = "",
            content = "";

        const prefix = this.client.configManager.config[message.guildId!]?.prefix ?? "-";

        if (message instanceof Message) {
            content = message.content;
            message.content = prefix + commandString;
        } else {
            commandName = message.commandName;
            message.commandName = commandString.split(/ +/)[0];

            if (this.client.commands.get(message.commandName) && !this.client.commands.get(message.commandName)?.supportsLegacy) {
                message.commandName = commandName;
                await this.error(message, "This command doesn't support legacy mode, and only legacy commands can be queued!");
                return;
            }
        }

        const result = await this.client.commandManager.runCommandFromMessage(message as Message, true, true);

        if (message instanceof Message) {
            message.content = content;
        } else {
            message.commandName = commandName;
        }

        if (result === null) {
            return;
        }

        if (result === false) {
            await this.error(message, `The command you've specified could not be found. Please check for spelling errors.`);
            return;
        }

        const id = await this.client.queueManager.add(
            new QueueEntry({
                args: [message.channelId!, message instanceof Message ? message.id : deferredMessage!.id, commandString],
                client: this.client,
                createdAt: new Date(),
                filePath: path.resolve(__dirname, "../../queues/CommandQueue"),
                guild: message.guild!,
                name: "CommandQueue",
                userId: message.member!.user.id,
                willRunAt: new Date(Date.now() + runAfter)
            })
        );

        await this.deferredReply(message, {
            embeds: [
                new EmbedBuilder({
                    title: "Queue created",
                    color: 0x007bff,
                    description: `${this.emoji(
                        "check"
                    )} Successfully added the queue. The following command will be run after **${formatDistanceToNowStrict(
                        new Date(Date.now() - runAfter)
                    )}**:\n\n\`\`\`${escapeMarkdown(prefix + commandString)}\`\`\``,
                    fields: [
                        {
                            name: "Queue ID",
                            value: id.toString()
                        }
                    ]
                }).setTimestamp()
            ]
        });
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import { formatDistanceToNowStrict } from "date-fns";
21			import { EmbedBuilder, Message, PermissionsBitField, escapeMarkdown } from "discord.js";
22			import path from "path";
23			import Command, { BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
24			import QueueEntry from "../../utils/QueueEntry";
25			import { stringToTimeInterval } from "../../utils/datetime";
26
27			export default class QueueAddCommand extends Command {
28			public readonly name = "queue__add";
29			public readonly validationRules: ValidationRule[] = [];
30			public readonly aliases = ["queueadd", "addqueue", "createqueue"];
31			public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
32			public readonly description = "Creates a new command queue";
33			public readonly since = "5.57.0";
34
35			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
36			const deferredMessage = await (await this.deferIfInteraction(message))?.fetch();
37			const runAfterString = context.isLegacy ? context.args[0] : context.options.getString("run_after", true);
38
39			if (!runAfterString) {
40			await this.error(message, "Please specify after how much time the queue should run!");
41			return;
42			}
43
44			const { error, result: runAfter } = stringToTimeInterval(runAfterString, { milliseconds: true });
45
46			if (error) {
47			await this.error(message, error);
48			return;
49			}
50
51			if (context.isLegacy && !context.args[1]) {
52			await this.error(message, "Please specify the command to queue!");
53			return;
54			}
55
56			const commandString = context.isLegacy
57			? (message as Message).content
58			.substring(this.client.configManager.config[message.guildId!]?.prefix?.length ?? 1)
59			.trimStart()
60			.substring(context.argv[0] === "queue" ? "queue".length : 0)
61			.trimStart()
62			.substring(context.argv[0] === "queue" ? this.name.replace("queue__", "").length : context.argv[0].length)
63			.trimStart()
64			.substring(runAfterString.length)
65			.trim()
66			: context.options.getString("command", true).trim();
67
68			let commandName = "",
69			content = "";
70
71			const prefix = this.client.configManager.config[message.guildId!]?.prefix ?? "-";
72
73			if (message instanceof Message) {
74			content = message.content;
75			message.content = prefix + commandString;
76			} else {
77			commandName = message.commandName;
78			message.commandName = commandString.split(/ +/)[0];
79
80			if (this.client.commands.get(message.commandName) && !this.client.commands.get(message.commandName)?.supportsLegacy) {
81			message.commandName = commandName;
82			await this.error(message, "This command doesn't support legacy mode, and only legacy commands can be queued!");
83			return;
84			}
85			}
86
87			const result = await this.client.commandManager.runCommandFromMessage(message as Message, true, true);
88
89			if (message instanceof Message) {
90			message.content = content;
91			} else {
92			message.commandName = commandName;
93			}
94
95			if (result === null) {
96			return;
97			}
98
99			if (result === false) {
100			await this.error(message, `The command you've specified could not be found. Please check for spelling errors.`);
101			return;
102			}
103
104			const id = await this.client.queueManager.add(
105			new QueueEntry({
106			args: [message.channelId!, message instanceof Message ? message.id : deferredMessage!.id, commandString],
107			client: this.client,
108			createdAt: new Date(),
109			filePath: path.resolve(__dirname, "../../queues/CommandQueue"),
110			guild: message.guild!,
111			name: "CommandQueue",
112			userId: message.member!.user.id,
113			willRunAt: new Date(Date.now() + runAfter)
114			})
115			);
116
117			await this.deferredReply(message, {
118			embeds: [
119			new EmbedBuilder({
120			title: "Queue created",
121			color: 0x007bff,
122			description: `${this.emoji(
123			"check"
124			)} Successfully added the queue. The following command will be run after **${formatDistanceToNowStrict(
125			new Date(Date.now() - runAfter)
126			)}**:\n\n\`\`\`${escapeMarkdown(prefix + commandString)}\`\`\``,
127			fields: [
128			{
129			name: "Queue ID",
130			value: id.toString()
131			}
132			]
133			}).setTimestamp()
134			]
135			});
136			}
137			}