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 { ChatInputCommandInteraction, 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];
        }

        const result = context.isLegacy
            ? await this.client.commandManager.runCommandFromMessage(message as Message, true)
            : await this.client.commandManager.runCommandFromCommandInteraction(message as ChatInputCommandInteraction, true);

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

        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	/**
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 { ChatInputCommandInteraction, 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
81	const result = context.isLegacy
82	? await this.client.commandManager.runCommandFromMessage(message as Message, true)
83	: await this.client.commandManager.runCommandFromCommandInteraction(message as ChatInputCommandInteraction, true);
84
85	if (message instanceof Message) {
86	message.content = content;
87	} else {
88	message.commandName = commandName;
89	}
90
91	if (result === false) {
92	await this.error(message, `The command you've specified could not be found. Please check for spelling errors.`);
93	return;
94	}
95
96	const id = await this.client.queueManager.add(
97	new QueueEntry({
98	args: [message.channelId!, message instanceof Message ? message.id : deferredMessage!.id, commandString],
99	client: this.client,
100	createdAt: new Date(),
101	filePath: path.resolve(__dirname, "../../queues/CommandQueue"),
102	guild: message.guild!,
103	name: "CommandQueue",
104	userId: message.member!.user.id,
105	willRunAt: new Date(Date.now() + runAfter)
106	})
107	);
108
109	await this.deferredReply(message, {
110	embeds: [
111	new EmbedBuilder({
112	title: "Queue created",
113	color: 0x007bff,
114	description: `${this.emoji(
115	"check"
116	)} Successfully added the queue. The following command will be run after **${formatDistanceToNowStrict(
117	new Date(Date.now() - runAfter)
118	)}**:\n\n\`\`\`${escapeMarkdown(prefix + commandString)}\`\`\``,
119	fields: [
120	{
121	name: "Queue ID",
122	value: id.toString()
123	}
124	]
125	}).setTimestamp()
126	]
127	});
128	}
129	}