commands/moderation/ReportMessageCommand.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 {
    ApplicationCommandType,
    Colors,
    EmbedBuilder,
    GuildMember,
    MessageContextMenuCommandInteraction,
    PermissionsString
} from "discord.js";
import Command, { CommandReturn, ValidationRule } from "../../core/Command";
import { ContextMenuCommandContext } from "../../services/CommandManager";
import { channelInfo, messageInfo, userInfo } from "../../utils/embed";
import { safeChannelFetch } from "../../utils/fetch";
import { logError } from "../../utils/logger";

export default class ReportMessageCommand extends Command {
    public readonly name = "Report Message";
    public readonly validationRules: ValidationRule[] = [];
    public readonly permissions = [];
    public readonly applicationCommandType = ApplicationCommandType.Message;

    public readonly supportsLegacy = false;
    public readonly description = "Reports the target message to the message log channel and deletes it.";

    async permissionCheck(interaction: MessageContextMenuCommandInteraction) {
        const config = this.client.configManager.config[interaction.guildId!]?.message_reporting;

        if (config?.users?.includes(interaction.user.id)) {
            return true;
        }

        const member = interaction.member as GuildMember;

        if (member?.roles.cache.hasAll(...(config?.roles ?? []))) {
            return true;
        }

        if (
            config?.permissionLevel !== undefined &&
            config?.permissionLevel >= 0 &&
            this.client.permissionManager.usesLevelBasedMode(member.guild.id) &&
            (await this.client.permissionManager.getManager(member.guild.id)).getPermissionLevel(member) >=
                config?.permissionLevel
        ) {
            return true;
        }

        if (member?.permissions.has((config?.permissions ?? []) as PermissionsString[], true)) {
            return true;
        }

        return false;
    }

    async execute(interaction: MessageContextMenuCommandInteraction, context: ContextMenuCommandContext): Promise<CommandReturn> {
        const { targetMessage } = interaction;

        await interaction.deferReply({ ephemeral: true });

        if (!(await this.client.permissionManager.shouldModerate(targetMessage.member!, interaction.member as GuildMember))) {
            await this.error(interaction, "You don't have permission to report messsages from this user!");
            return;
        }

        if (!(await this.permissionCheck(interaction))) {
            await this.error(interaction, "You don't have permission to run this command");
            return;
        }

        if (!this.client.configManager.config[interaction.guildId!]?.message_reporting?.enabled) {
            await interaction.editReply({
                content: "This server has message reporting turned off. Please turn it on to use this command."
            });

            return;
        }

        const channelId =
            this.client.configManager.config[interaction.guildId!]?.message_reporting?.channel ??
            this.client.configManager.config[interaction.guildId!]?.logging?.primary_channel;

        if (!channelId) {
            await interaction.editReply({
                content: "This server does not have report logging channel set up. Please set it up first."
            });

            return;
        }

        const channel = await safeChannelFetch(interaction.guild!, channelId!);

        if (!channel?.isTextBased()) {
            await interaction.editReply({
                content: "Could not send the reported message to the log channel. This is probably due to a misconfiguration."
            });
            return;
        }

        let url = "";

        try {
            url = (
                await channel.send({
                    embeds: [
                        new EmbedBuilder({
                            color: Colors.Red,
                            title: "Message reported",
                            author: {
                                name: targetMessage.author.username,
                                icon_url: targetMessage.author.displayAvatarURL()
                            },
                            description: targetMessage.content ?? "No content",
                            fields: [
                                {
                                    name: "User",
                                    value: userInfo(targetMessage.author),
                                    inline: true
                                },
                                {
                                    name: "Reported By",
                                    value: userInfo(interaction.user),
                                    inline: true
                                },
                                {
                                    name: "Message",
                                    value: messageInfo(targetMessage)
                                },
                                {
                                    name: "Channel",
                                    value: channelInfo(targetMessage.channel)
                                }
                            ],
                            footer: {
                                text: "Reported"
                            }
                        }).setTimestamp()
                    ],
                    files: targetMessage.attachments.toJSON()
                })
            ).url;
        } catch (e) {
            logError(e);
            await this.error(
                interaction,
                "Could not send the reported message into the log channel! Make sure I have enough permissions."
            );
            return;
        }

        try {
            await targetMessage.delete();
        } catch (e) {
            logError(e);
            await this.error(interaction, "Could not remove the reported message! Make sure I have enough permissions.");
        }

        await this.success(
            interaction,
            `The message was reported and removed. [Click here](${url}) to nagivate to the reported message.`
        );
    }
}
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			ApplicationCommandType,
22			Colors,
23			EmbedBuilder,
24			GuildMember,
25			MessageContextMenuCommandInteraction,
26			PermissionsString
27			} from "discord.js";
28			import Command, { CommandReturn, ValidationRule } from "../../core/Command";
29			import { ContextMenuCommandContext } from "../../services/CommandManager";
30			import { channelInfo, messageInfo, userInfo } from "../../utils/embed";
31			import { safeChannelFetch } from "../../utils/fetch";
32			import { logError } from "../../utils/logger";
33
34			export default class ReportMessageCommand extends Command {
35			public readonly name = "Report Message";
36			public readonly validationRules: ValidationRule[] = [];
37			public readonly permissions = [];
38			public readonly applicationCommandType = ApplicationCommandType.Message;
39
40			public readonly supportsLegacy = false;
41			public readonly description = "Reports the target message to the message log channel and deletes it.";
42
43			async permissionCheck(interaction: MessageContextMenuCommandInteraction) {
44			const config = this.client.configManager.config[interaction.guildId!]?.message_reporting;
45
46			if (config?.users?.includes(interaction.user.id)) {
47			return true;
48			}
49
50			const member = interaction.member as GuildMember;
51
52			if (member?.roles.cache.hasAll(...(config?.roles ?? []))) {
53			return true;
54			}
55
56			if (
57			config?.permissionLevel !== undefined &&
58			config?.permissionLevel >= 0 &&
59			this.client.permissionManager.usesLevelBasedMode(member.guild.id) &&
60			(await this.client.permissionManager.getManager(member.guild.id)).getPermissionLevel(member) >=
61			config?.permissionLevel
62			) {
63			return true;
64			}
65
66			if (member?.permissions.has((config?.permissions ?? []) as PermissionsString[], true)) {
67			return true;
68			}
69
70			return false;
71			}
72
73			async execute(interaction: MessageContextMenuCommandInteraction, context: ContextMenuCommandContext): Promise<CommandReturn> {
74			const { targetMessage } = interaction;
75
76			await interaction.deferReply({ ephemeral: true });
77
78			if (!(await this.client.permissionManager.shouldModerate(targetMessage.member!, interaction.member as GuildMember))) {
79			await this.error(interaction, "You don't have permission to report messsages from this user!");
80			return;
81			}
82
83			if (!(await this.permissionCheck(interaction))) {
84			await this.error(interaction, "You don't have permission to run this command");
85			return;
86			}
87
88			if (!this.client.configManager.config[interaction.guildId!]?.message_reporting?.enabled) {
89			await interaction.editReply({
90			content: "This server has message reporting turned off. Please turn it on to use this command."
91			});
92
93			return;
94			}
95
96			const channelId =
97			this.client.configManager.config[interaction.guildId!]?.message_reporting?.channel ??
98			this.client.configManager.config[interaction.guildId!]?.logging?.primary_channel;
99
100			if (!channelId) {
101			await interaction.editReply({
102			content: "This server does not have report logging channel set up. Please set it up first."
103			});
104
105			return;
106			}
107
108			const channel = await safeChannelFetch(interaction.guild!, channelId!);
109
110			if (!channel?.isTextBased()) {
111			await interaction.editReply({
112			content: "Could not send the reported message to the log channel. This is probably due to a misconfiguration."
113			});
114			return;
115			}
116
117			let url = "";
118
119			try {
120			url = (
121			await channel.send({
122			embeds: [
123			new EmbedBuilder({
124			color: Colors.Red,
125			title: "Message reported",
126			author: {
127			name: targetMessage.author.username,
128			icon_url: targetMessage.author.displayAvatarURL()
129			},
130			description: targetMessage.content ?? "No content",
131			fields: [
132			{
133			name: "User",
134			value: userInfo(targetMessage.author),
135			inline: true
136			},
137			{
138			name: "Reported By",
139			value: userInfo(interaction.user),
140			inline: true
141			},
142			{
143			name: "Message",
144			value: messageInfo(targetMessage)
145			},
146			{
147			name: "Channel",
148			value: channelInfo(targetMessage.channel)
149			}
150			],
151			footer: {
152			text: "Reported"
153			}
154			}).setTimestamp()
155			],
156			files: targetMessage.attachments.toJSON()
157			})
158			).url;
159			} catch (e) {
160			logError(e);
161			await this.error(
162			interaction,
163			"Could not send the reported message into the log channel! Make sure I have enough permissions."
164			);
165			return;
166			}
167
168			try {
169			await targetMessage.delete();
170			} catch (e) {
171			logError(e);
172			await this.error(interaction, "Could not remove the reported message! Make sure I have enough permissions.");
173			}
174
175			await this.success(
176			interaction,
177			`The message was reported and removed. [Click here](${url}) to nagivate to the reported message.`
178			);
179			}
180			}