commands/moderation/SendReplyCommand.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* 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 { CommandInteraction, ContextMenuInteraction, Message, MessageActionRow, Modal, ModalSubmitInteraction, NewsChannel, Permissions, TextChannel, TextInputComponent, ThreadChannel, User } from 'discord.js';
import BaseCommand from '../../utils/structures/BaseCommand';
import DiscordClient from '../../client/Client';
import InteractionOptions from '../../types/InteractionOptions';
import MessageEmbed from '../../client/MessageEmbed';
import { LogLevel } from '../../services/DebugLogger';

let globalInteraction: CommandInteraction | ContextMenuInteraction;
let globalMessage: Message;

export default class SendReplyCommand extends BaseCommand {
    supportsContextMenu: boolean = true;
    supportsInteractions: boolean = true;
    supportsLegacy: boolean = false;
    permissions = [Permissions.FLAGS.MANAGE_MESSAGES];

    constructor() {
        super('reply', 'moderation', ['Send Reply']);
    }

    async innerRun(interaction: ModalSubmitInteraction) {
        if (!this.filter(interaction)) {
            return;
        }
        
        try {                
            await (globalMessage.channel as TextChannel).sendTyping();
            await globalMessage.reply({ content: interaction.fields.getTextInputValue('content') });
            await interaction.reply({ ephemeral: true, content: "Message sent!" });
        }
        catch (e) {
            console.log(e);
            
            await interaction.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`Failed to send message. Maybe missing permissions or invalid embed schema?`)
                ],
                ephemeral: true
            });

            return;
        }
    }

    filter(i: ModalSubmitInteraction) {
        return i.user.id === globalInteraction.user.id && i.customId === 'send_reply_modal';
    }

    async run(client: DiscordClient, interaction: CommandInteraction | ContextMenuInteraction, options: InteractionOptions) {
        let message: Message;

        if (interaction.isMessageContextMenu()) {
            globalInteraction = interaction;
            message = <Message> interaction.targetMessage;
            globalMessage = message;
            
            const modal = new Modal()
                .setCustomId("send_reply_modal")
                .setTitle("Send Reply")
                .addComponents(
                    new MessageActionRow<TextInputComponent>()
                        .addComponents(
                            new TextInputComponent()
                                .setCustomId("content")
                                .setLabel("Message Content")
                                .setMinLength(1)
                                .setPlaceholder("Type your message...")
                                .setRequired(true)
                                .setStyle("PARAGRAPH")
                        )
                );

            await interaction.showModal(modal);
        }
        else if (interaction.isCommand()) {
            const channel = <TextChannel | NewsChannel | ThreadChannel> interaction.options.getChannel("channel") ?? interaction.channel!;

            if (channel.type !== 'GUILD_NEWS' && channel.type !== "GUILD_TEXT" && !channel.type.toString().endsWith('_THREAD')) {
                await interaction.reply({ content: "You must select a valid text channel, where the bot can send messages.", ephemeral: true });
                return;
            }
            
            await interaction.deferReply({ ephemeral: true });

            try {
                message = await channel.messages.fetch(interaction.options.getString("message_id", true));

                if (!message) {
                    throw new Error();
                }
            }
            catch (e) {
                console.log(e);

                await this.deferReply(interaction, {
                    content: "No such message found with the given ID."
                });

                return;
            }

            const content = interaction.options.getString("content", true);

            const log = `======== ${(interaction.member!.user as User).tag} (ID: ${(interaction.member!.user as User).id}) executed send reply command (Guild: ${interaction.guildId}) =====`;
            console.log(log);
            client.debugLogger.logApp(LogLevel.INFO, log);
            
            try {                
                await message.reply({ content });
                await this.deferReply(interaction, {
                    content: "Reply sent!"
                });
            }
            catch (e) {
                console.log(e);
                
                await this.deferReply(interaction, {
                    embeds: [
                        new MessageEmbed()
                        .setColor('#f14a60')
                        .setDescription(`Failed to send message. Maybe missing permissions or invalid embed schema?`)
                    ],
                });

                return;
            }
        }
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2022 OSN Inc.
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 { CommandInteraction, ContextMenuInteraction, Message, MessageActionRow, Modal, ModalSubmitInteraction, NewsChannel, Permissions, TextChannel, TextInputComponent, ThreadChannel, User } from 'discord.js';
21			import BaseCommand from '../../utils/structures/BaseCommand';
22			import DiscordClient from '../../client/Client';
23			import InteractionOptions from '../../types/InteractionOptions';
24			import MessageEmbed from '../../client/MessageEmbed';
25			import { LogLevel } from '../../services/DebugLogger';
26
27			let globalInteraction: CommandInteraction \| ContextMenuInteraction;
28			let globalMessage: Message;
29
30			export default class SendReplyCommand extends BaseCommand {
31			supportsContextMenu: boolean = true;
32			supportsInteractions: boolean = true;
33			supportsLegacy: boolean = false;
34			permissions = [Permissions.FLAGS.MANAGE_MESSAGES];
35
36			constructor() {
37			super('reply', 'moderation', ['Send Reply']);
38			}
39
40			async innerRun(interaction: ModalSubmitInteraction) {
41			if (!this.filter(interaction)) {
42			return;
43			}
44
45			try {
46			await (globalMessage.channel as TextChannel).sendTyping();
47			await globalMessage.reply({ content: interaction.fields.getTextInputValue('content') });
48			await interaction.reply({ ephemeral: true, content: "Message sent!" });
49			}
50			catch (e) {
51			console.log(e);
52
53			await interaction.reply({
54			embeds: [
55			new MessageEmbed()
56			.setColor('#f14a60')
57			.setDescription(`Failed to send message. Maybe missing permissions or invalid embed schema?`)
58			],
59			ephemeral: true
60			});
61
62			return;
63			}
64			}
65
66			filter(i: ModalSubmitInteraction) {
67			return i.user.id === globalInteraction.user.id && i.customId === 'send_reply_modal';
68			}
69
70			async run(client: DiscordClient, interaction: CommandInteraction \| ContextMenuInteraction, options: InteractionOptions) {
71			let message: Message;
72
73			if (interaction.isMessageContextMenu()) {
74			globalInteraction = interaction;
75			message = <Message> interaction.targetMessage;
76			globalMessage = message;
77
78			const modal = new Modal()
79			.setCustomId("send_reply_modal")
80			.setTitle("Send Reply")
81			.addComponents(
82			new MessageActionRow<TextInputComponent>()
83			.addComponents(
84			new TextInputComponent()
85			.setCustomId("content")
86			.setLabel("Message Content")
87			.setMinLength(1)
88			.setPlaceholder("Type your message...")
89			.setRequired(true)
90			.setStyle("PARAGRAPH")
91			)
92			);
93
94			await interaction.showModal(modal);
95			}
96			else if (interaction.isCommand()) {
97			const channel = <TextChannel \| NewsChannel \| ThreadChannel> interaction.options.getChannel("channel") ?? interaction.channel!;
98
99			if (channel.type !== 'GUILD_NEWS' && channel.type !== "GUILD_TEXT" && !channel.type.toString().endsWith('_THREAD')) {
100			await interaction.reply({ content: "You must select a valid text channel, where the bot can send messages.", ephemeral: true });
101			return;
102			}
103
104			await interaction.deferReply({ ephemeral: true });
105
106			try {
107			message = await channel.messages.fetch(interaction.options.getString("message_id", true));
108
109			if (!message) {
110			throw new Error();
111			}
112			}
113			catch (e) {
114			console.log(e);
115
116			await this.deferReply(interaction, {
117			content: "No such message found with the given ID."
118			});
119
120			return;
121			}
122
123			const content = interaction.options.getString("content", true);
124
125			const log = `======== ${(interaction.member!.user as User).tag} (ID: ${(interaction.member!.user as User).id}) executed send reply command (Guild: ${interaction.guildId}) =====`;
126			console.log(log);
127			client.debugLogger.logApp(LogLevel.INFO, log);
128
129			try {
130			await message.reply({ content });
131			await this.deferReply(interaction, {
132			content: "Reply sent!"
133			});
134			}
135			catch (e) {
136			console.log(e);
137
138			await this.deferReply(interaction, {
139			embeds: [
140			new MessageEmbed()
141			.setColor('#f14a60')
142			.setDescription(`Failed to send message. Maybe missing permissions or invalid embed schema?`)
143			],
144			});
145
146			return;
147			}
148			}
149			}
150			}