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";
    public readonly supportsInteractions: boolean = true;
    public readonly supportsLegacy: boolean = true;

    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, {
24			BasicCommandContext,
25			CommandMessage,
26			CommandReturn,
27			ValidationRule
28			} from "../../core/Command";
29			import QueueEntry from "../../utils/QueueEntry";
30			import { stringToTimeInterval } from "../../utils/datetime";
31
32			export default class QueueAddCommand extends Command {
33			public readonly name = "queue__add";
34			public readonly validationRules: ValidationRule[] = [];
35			public readonly aliases = ["queueadd", "addqueue", "createqueue"];
36			public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
37			public readonly description = "Creates a new command queue";
38			public readonly since = "5.57.0";
39			public readonly supportsInteractions: boolean = true;
40			public readonly supportsLegacy: boolean = true;
41
42			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
43			const deferredMessage = await (await this.deferIfInteraction(message))?.fetch();
44			const runAfterString = context.isLegacy
45			? context.args[0]
46			: context.options.getString("run_after", true);
47
48			if (!runAfterString) {
49			await this.error(message, "Please specify after how much time the queue should run!");
50			return;
51			}
52
53			const { error, result: runAfter } = stringToTimeInterval(runAfterString, {
54			milliseconds: true
55			});
56
57			if (error) {
58			await this.error(message, error);
59			return;
60			}
61
62			if (context.isLegacy && !context.args[1]) {
63			await this.error(message, "Please specify the command to queue!");
64			return;
65			}
66
67			const commandString = context.isLegacy
68			? (message as Message).content
69			.substring(
70			this.client.configManager.config[message.guildId!]?.prefix?.length ?? 1
71			)
72			.trimStart()
73			.substring(context.argv[0] === "queue" ? "queue".length : 0)
74			.trimStart()
75			.substring(
76			context.argv[0] === "queue"
77			? this.name.replace("queue__", "").length
78			: context.argv[0].length
79			)
80			.trimStart()
81			.substring(runAfterString.length)
82			.trim()
83			: context.options.getString("command", true).trim();
84
85			let commandName = "",
86			content = "";
87
88			const prefix = this.client.configManager.config[message.guildId!]?.prefix ?? "-";
89
90			if (message instanceof Message) {
91			content = message.content;
92			message.content = prefix + commandString;
93			} else {
94			commandName = message.commandName;
95			message.commandName = commandString.split(/ +/)[0];
96
97			if (
98			this.client.commands.get(message.commandName) &&
99			!this.client.commands.get(message.commandName)?.supportsLegacy
100			) {
101			message.commandName = commandName;
102			await this.error(
103			message,
104			"This command doesn't support legacy mode, and only legacy commands can be queued!"
105			);
106			return;
107			}
108			}
109
110			const result = await this.client.commandManager.runCommandFromMessage(
111			message as Message,
112			true,
113			true
114			);
115
116			if (message instanceof Message) {
117			message.content = content;
118			} else {
119			message.commandName = commandName;
120			}
121
122			if (result === null) {
123			return;
124			}
125
126			if (result === false) {
127			await this.error(
128			message,
129			"The command you've specified could not be found. Please check for spelling errors."
130			);
131			return;
132			}
133
134			const id = await this.client.queueManager.add(
135			new QueueEntry({
136			args: [
137			message.channelId!,
138			message instanceof Message ? message.id : deferredMessage!.id,
139			commandString
140			],
141			client: this.client,
142			createdAt: new Date(),
143			filePath: path.resolve(__dirname, "../../queues/CommandQueue"),
144			guild: message.guild!,
145			name: "CommandQueue",
146			userId: message.member!.user.id,
147			willRunAt: new Date(Date.now() + runAfter)
148			})
149			);
150
151			await this.deferredReply(message, {
152			embeds: [
153			new EmbedBuilder({
154			title: "Queue created",
155			color: 0x007bff,
156			description: `${this.emoji(
157			"check"
158			)} Successfully added the queue. The following command will be run after **${formatDistanceToNowStrict(
159			new Date(Date.now() - runAfter)
160			)}**:\n\n\`\`\`${escapeMarkdown(prefix + commandString)}\`\`\``,
161			fields: [
162			{
163			name: "Queue ID",
164			value: id.toString()
165			}
166			]
167			}).setTimestamp()
168			]
169			});
170			}
171			}