commands/moderation/ReportCommand.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 { ModalSubmitInteraction } from 'discord-modals';
import { Message, Interaction, CacheType, MessageContextMenuInteraction, Modal, MessageActionRow, TextInputComponent, TextChannel, GuildMember } from 'discord.js';
import DiscordClient from '../../client/Client';
import MessageEmbed from '../../client/MessageEmbed';
import CommandOptions from '../../types/CommandOptions';
import InteractionOptions from '../../types/InteractionOptions';
import BaseCommand from '../../utils/structures/BaseCommand';

export default class ReportCommand extends BaseCommand {
    name = "Report Message";
    category = "moderation";
    ids: { [randomId: string]: Message } = {};
    supportsInteractions = true;
    supportsContextMenu = true;

    async modalSubmit(client: DiscordClient, interaction: ModalSubmitInteraction): Promise<void> {
        if (!(await this.verify(client, interaction))) {
            return;
        }

        const { customId, guild } = interaction;
        const targetMessage = this.ids[customId];

        if (!targetMessage) {
            await interaction.reply({ content: "Whoops! Something unexpected happened here! Please try again", ephemeral: true });
            return;
        }

        try {
            const { logging_channel } = client.config.props[guild!.id] ?? {};
            const channel = <TextChannel> await guild!.channels.fetch(logging_channel);

            if (channel && channel.send) {
                await channel.send({
                    embeds: [
                        new MessageEmbed({
                            author: {
                                name: targetMessage.author.tag,
                                iconURL: targetMessage.author.displayAvatarURL(),
                            },
                            description: targetMessage.content ?? '*No Content*',
                            title: 'Message Reported',
                            fields: [
                                {
                                    name: "Reported by",
                                    value: interaction.user!.tag
                                }
                            ],
                            footer: {
                                text: 'Report Received'
                            }
                        })
                        .setTimestamp()
                        .setColor('#f14a60')
                    ],
                    files: [...targetMessage.attachments.values()],
                    stickers: [...targetMessage.stickers.values()]
                });
            }
        }
        catch (e) {
            console.log(e);
            await interaction.reply({ content: "Could not report that message. An internal error has occurred.", ephemeral: true });
            return;
        }

        try {
            await targetMessage.delete();
        }
        catch (e) {
            await interaction.reply({ content: "Could not remove that message. Probably the author has deleted it or I don't have enough permissions.", ephemeral: true });
            return;
        }

        await interaction.reply({ content: "The message has been reported. Moderators will take action soon.", ephemeral: true });
    }

    async verify(client: DiscordClient, interaction: MessageContextMenuInteraction | ModalSubmitInteraction) {
        const member = interaction.member as GuildMember;
        const config = client.config.props[member.guild.id].reports;

        if (!config.enabled) {
            await interaction.reply({ ephemeral: true, content: "Message reports are disabled in this server." });
            return false;
        }

        if (member.roles.cache.has(client.config.props[(interaction.member as GuildMember).guild.id].mod_role)) {
            return true;
        }

        if (config.mod_only && !member.roles.cache.has(client.config.props[(interaction.member as GuildMember).guild.id].mod_role)) {
            await interaction.reply({ ephemeral: true, content: "Only moderators can report messages." });
            return false;
        }

        for (const roleID of config.reporter_roles) {
            if (roleID === 'everyone') {
                return true;
            }
            
            if (member.roles.cache.has(roleID)) {
                return true;
            }
        }

        if (config.reporters.includes(interaction.member!.user.id)) {
            return true;
        }
        
        await interaction.reply({ ephemeral: true, content: "You're not permitted to report messages." });
        return false;
    }

    async run(client: DiscordClient, interaction: MessageContextMenuInteraction, options: InteractionOptions): Promise<void> {
        if (!(await this.verify(client, interaction))) {
            return;
        }

        const randomId = 'report_modal_' + Math.round(Math.random() * 10000000);
        const { targetMessage } = interaction;
        const modal = new Modal()
            .setCustomId(randomId)
            .setTitle("Report Message")
            .addComponents(
                new MessageActionRow<TextInputComponent>()
                    .addComponents(
                        new TextInputComponent()
                            .setCustomId('reason')
                            .setLabel("Reason")
                            .setPlaceholder("Why are you reporting this message?")
                            .setMinLength(1)
                            .setRequired(true)
                            .setStyle('PARAGRAPH')
                    )
            );

        await interaction.showModal(modal);
        this.ids[randomId] = targetMessage as Message;
    }
}
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 { ModalSubmitInteraction } from 'discord-modals';
21			import { Message, Interaction, CacheType, MessageContextMenuInteraction, Modal, MessageActionRow, TextInputComponent, TextChannel, GuildMember } from 'discord.js';
22			import DiscordClient from '../../client/Client';
23			import MessageEmbed from '../../client/MessageEmbed';
24			import CommandOptions from '../../types/CommandOptions';
25			import InteractionOptions from '../../types/InteractionOptions';
26			import BaseCommand from '../../utils/structures/BaseCommand';
27
28			export default class ReportCommand extends BaseCommand {
29			name = "Report Message";
30			category = "moderation";
31			ids: { [randomId: string]: Message } = {};
32			supportsInteractions = true;
33			supportsContextMenu = true;
34
35			async modalSubmit(client: DiscordClient, interaction: ModalSubmitInteraction): Promise<void> {
36			if (!(await this.verify(client, interaction))) {
37			return;
38			}
39
40			const { customId, guild } = interaction;
41			const targetMessage = this.ids[customId];
42
43			if (!targetMessage) {
44			await interaction.reply({ content: "Whoops! Something unexpected happened here! Please try again", ephemeral: true });
45			return;
46			}
47
48			try {
49			const { logging_channel } = client.config.props[guild!.id] ?? {};
50			const channel = <TextChannel> await guild!.channels.fetch(logging_channel);
51
52			if (channel && channel.send) {
53			await channel.send({
54			embeds: [
55			new MessageEmbed({
56			author: {
57			name: targetMessage.author.tag,
58			iconURL: targetMessage.author.displayAvatarURL(),
59			},
60			description: targetMessage.content ?? 'No Content',
61			title: 'Message Reported',
62			fields: [
63			{
64			name: "Reported by",
65			value: interaction.user!.tag
66			}
67			],
68			footer: {
69			text: 'Report Received'
70			}
71			})
72			.setTimestamp()
73			.setColor('#f14a60')
74			],
75			files: [...targetMessage.attachments.values()],
76			stickers: [...targetMessage.stickers.values()]
77			});
78			}
79			}
80			catch (e) {
81			console.log(e);
82			await interaction.reply({ content: "Could not report that message. An internal error has occurred.", ephemeral: true });
83			return;
84			}
85
86			try {
87			await targetMessage.delete();
88			}
89			catch (e) {
90			await interaction.reply({ content: "Could not remove that message. Probably the author has deleted it or I don't have enough permissions.", ephemeral: true });
91			return;
92			}
93
94			await interaction.reply({ content: "The message has been reported. Moderators will take action soon.", ephemeral: true });
95			}
96
97			async verify(client: DiscordClient, interaction: MessageContextMenuInteraction \| ModalSubmitInteraction) {
98			const member = interaction.member as GuildMember;
99			const config = client.config.props[member.guild.id].reports;
100
101			if (!config.enabled) {
102			await interaction.reply({ ephemeral: true, content: "Message reports are disabled in this server." });
103			return false;
104			}
105
106			if (member.roles.cache.has(client.config.props[(interaction.member as GuildMember).guild.id].mod_role)) {
107			return true;
108			}
109
110			if (config.mod_only && !member.roles.cache.has(client.config.props[(interaction.member as GuildMember).guild.id].mod_role)) {
111			await interaction.reply({ ephemeral: true, content: "Only moderators can report messages." });
112			return false;
113			}
114
115			for (const roleID of config.reporter_roles) {
116			if (roleID === 'everyone') {
117			return true;
118			}
119
120			if (member.roles.cache.has(roleID)) {
121			return true;
122			}
123			}
124
125			if (config.reporters.includes(interaction.member!.user.id)) {
126			return true;
127			}
128
129			await interaction.reply({ ephemeral: true, content: "You're not permitted to report messages." });
130			return false;
131			}
132
133			async run(client: DiscordClient, interaction: MessageContextMenuInteraction, options: InteractionOptions): Promise<void> {
134			if (!(await this.verify(client, interaction))) {
135			return;
136			}
137
138			const randomId = 'report_modal_' + Math.round(Math.random() * 10000000);
139			const { targetMessage } = interaction;
140			const modal = new Modal()
141			.setCustomId(randomId)
142			.setTitle("Report Message")
143			.addComponents(
144			new MessageActionRow<TextInputComponent>()
145			.addComponents(
146			new TextInputComponent()
147			.setCustomId('reason')
148			.setLabel("Reason")
149			.setPlaceholder("Why are you reporting this message?")
150			.setMinLength(1)
151			.setRequired(true)
152			.setStyle('PARAGRAPH')
153			)
154			);
155
156			await interaction.showModal(modal);
157			this.ids[randomId] = targetMessage as Message;
158			}
159			}