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	/**
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	}