commands/moderation/EchoCommand.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 {
    APIEmbed,
    AttachmentPayload,
    Channel,
    GuildChannel,
    Message,
    PermissionsBitField,
    SlashCommandBuilder,
    TextChannel
} from "discord.js";
import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import EmbedSchemaParser from "../../utils/EmbedSchemaParser";
import { messageInfo } from "../../utils/embed";
import { logError } from "../../utils/logger";
import { getEmojiObject, isTextableChannel } from "../../utils/utils";

export default class EchoCommand extends Command {
    public readonly name = "echo";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.Channel, ArgumentType.StringRest],
            name: "channelOrContent",
            entity: {
                notNull: true
            },
            errors: {
                "entity:null": "This channel does not exist!",
                required: "Please provide the message content!"
            }
        },
        {
            types: [ArgumentType.StringRest],
            name: "content",
            optional: true
        }
    ];
    public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
    public readonly aliases = ["e", "say"];

    public readonly description = "Make the bot say something.";
    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addStringOption(option => option.setName("content").setDescription("Message content").setRequired(true))
        .addChannelOption(option => option.setName("channel").setDescription("The channel where the message will be sent"));

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        await this.deferIfInteraction(message, {
            ephemeral: true
        });

        const echoMentions = this.client.configManager.config[message.guildId!]?.commands?.echo_mentions ?? false;
        const deleteReply =
            this.client.configManager.config[message.guildId!]?.commands?.moderation_command_behaviour === "delete";

        const channel: TextChannel =
            (!context.isLegacy
                ? context.options.getChannel("channel")
                : context.parsedNamedArgs.channelOrContent && typeof context.parsedNamedArgs.channelOrContent === "object"
                ? context.parsedNamedArgs.channelOrContent
                : undefined) ?? message.channel;

        if (channel instanceof GuildChannel && !isTextableChannel(channel as Channel)) {
            await this.error(message, "Please provide a text channel!");
            return;
        }

        const content: string | undefined =
            (!context.isLegacy
                ? context.options.getString("content", true)
                : typeof context.parsedNamedArgs.channelOrContent === "string"
                ? context.parsedNamedArgs.channelOrContent
                : context.parsedNamedArgs.content) ?? undefined;

        if (!content && message instanceof Message && message.attachments.size === 0) {
            await this.error(message, "Please provide the message content or attachments!");
            return;
        }

        const options = {
            content,
            files:
                message instanceof Message
                    ? message.attachments.map(
                          a =>
                              ({
                                  attachment: a.proxyURL,
                                  name: a.name,
                                  description: a.description
                              } as AttachmentPayload)
                      )
                    : undefined,
            allowedMentions: (message.member?.permissions as Readonly<PermissionsBitField>)?.has("MentionEveryone", true)
                ? undefined
                : echoMentions
                ? undefined
                : {
                      parse: ["users" as const]
                  }
        };
        const echoedMessage = await EmbedSchemaParser.sendMessage(channel, options);

        if (message instanceof Message) {
            deleteReply && message.deletable
                ? await message.delete().catch(logError)
                : await message.react(getEmojiObject(this.client, "check") ?? "✅");
        } else {
            await this.deferredReply(message, `Message sent.`);
        }

        const embed: APIEmbed = {};

        await this.sendCommandRanLog(message, embed, {
            previews: [options],
            url: echoedMessage.url,
            async before(channel, sentMessages) {
                embed.description = `The message preview is [above](${sentMessages[0]?.url}).`;
            },
            fields(fields) {
                return [
                    ...fields,
                    {
                        name: "Message Info",
                        value: !echoedMessage ? "*Not available*" : messageInfo(echoedMessage)
                    }
                ];
            }
        });
    }
}
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 {
21			APIEmbed,
22			AttachmentPayload,
23			Channel,
24			GuildChannel,
25			Message,
26			PermissionsBitField,
27			SlashCommandBuilder,
28			TextChannel
29			} from "discord.js";
30			import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
31			import EmbedSchemaParser from "../../utils/EmbedSchemaParser";
32			import { messageInfo } from "../../utils/embed";
33			import { logError } from "../../utils/logger";
34			import { getEmojiObject, isTextableChannel } from "../../utils/utils";
35
36			export default class EchoCommand extends Command {
37			public readonly name = "echo";
38			public readonly validationRules: ValidationRule[] = [
39			{
40			types: [ArgumentType.Channel, ArgumentType.StringRest],
41			name: "channelOrContent",
42			entity: {
43			notNull: true
44			},
45			errors: {
46			"entity:null": "This channel does not exist!",
47			required: "Please provide the message content!"
48			}
49			},
50			{
51			types: [ArgumentType.StringRest],
52			name: "content",
53			optional: true
54			}
55			];
56			public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
57			public readonly aliases = ["e", "say"];
58
59			public readonly description = "Make the bot say something.";
60			public readonly slashCommandBuilder = new SlashCommandBuilder()
61			.addStringOption(option => option.setName("content").setDescription("Message content").setRequired(true))
62			.addChannelOption(option => option.setName("channel").setDescription("The channel where the message will be sent"));
63
64			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
65			await this.deferIfInteraction(message, {
66			ephemeral: true
67			});
68
69			const echoMentions = this.client.configManager.config[message.guildId!]?.commands?.echo_mentions ?? false;
70			const deleteReply =
71			this.client.configManager.config[message.guildId!]?.commands?.moderation_command_behaviour === "delete";
72
73			const channel: TextChannel =
74			(!context.isLegacy
75			? context.options.getChannel("channel")
76			: context.parsedNamedArgs.channelOrContent && typeof context.parsedNamedArgs.channelOrContent === "object"
77			? context.parsedNamedArgs.channelOrContent
78			: undefined) ?? message.channel;
79
80			if (channel instanceof GuildChannel && !isTextableChannel(channel as Channel)) {
81			await this.error(message, "Please provide a text channel!");
82			return;
83			}
84
85			const content: string \| undefined =
86			(!context.isLegacy
87			? context.options.getString("content", true)
88			: typeof context.parsedNamedArgs.channelOrContent === "string"
89			? context.parsedNamedArgs.channelOrContent
90			: context.parsedNamedArgs.content) ?? undefined;
91
92			if (!content && message instanceof Message && message.attachments.size === 0) {
93			await this.error(message, "Please provide the message content or attachments!");
94			return;
95			}
96
97			const options = {
98			content,
99			files:
100			message instanceof Message
101			? message.attachments.map(
102			a =>
103			({
104			attachment: a.proxyURL,
105			name: a.name,
106			description: a.description
107			} as AttachmentPayload)
108			)
109			: undefined,
110			allowedMentions: (message.member?.permissions as Readonly<PermissionsBitField>)?.has("MentionEveryone", true)
111			? undefined
112			: echoMentions
113			? undefined
114			: {
115			parse: ["users" as const]
116			}
117			};
118			const echoedMessage = await EmbedSchemaParser.sendMessage(channel, options);
119
120			if (message instanceof Message) {
121			deleteReply && message.deletable
122			? await message.delete().catch(logError)
123			: await message.react(getEmojiObject(this.client, "check") ?? "✅");
124			} else {
125			await this.deferredReply(message, `Message sent.`);
126			}
127
128			const embed: APIEmbed = {};
129
130			await this.sendCommandRanLog(message, embed, {
131			previews: [options],
132			url: echoedMessage.url,
133			async before(channel, sentMessages) {
134			embed.description = `The message preview is [above](${sentMessages[0]?.url}).`;
135			},
136			fields(fields) {
137			return [
138			...fields,
139			{
140			name: "Message Info",
141			value: !echoedMessage ? "Not available" : messageInfo(echoedMessage)
142			}
143			];
144			}
145			});
146			}
147			}