commands/moderation/ClearCommand.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 {
    Channel,
    ChatInputCommandInteraction,
    GuildMember,
    Message,
    PermissionsBitField,
    SlashCommandBuilder,
    TextChannel,
    User
} from "discord.js";
import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { logError } from "../../utils/logger";
import { isTextableChannel } from "../../utils/utils";

const THREE_DAYS = 1000 * 60 * 60 * 24 * 3;

const filters = {
    bots: (message: Message) => message.author.bot,
    mentions: (message: Message) => /<(@!?|#|@&)\d+>/.test(message.content),
    unverified_bots: (message: Message) => message.author.bot && !message.author.flags?.has("VerifiedBot"),
    users: (message: Message) => !message.author.bot,
    new_users: (message: Message) => !message.author.bot && message.createdAt.getTime() <= THREE_DAYS,
    embeds: (message: Message) => message.embeds.length > 0
};

const filter_aliases: Record<string, keyof typeof filters> = {
    bc: "bots",
    hc: "users",
    ec: "embeds",
    nc: "new_users",
    mc: "mentions"
};

export default class ClearCommand extends Command {
    public readonly name = "clear";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.User, ArgumentType.Integer],
            entity: {
                notNull: true
            },
            name: "countOrUser", // TODO: Be sure to support multiple names for the same argument [User, Integer] -> ['user', 'count'] = [User, 10]
            errors: {
                "entity:null": "This user does not exist! If it's an ID, make sure it's correct!",
                required: "You must specify the count of messages to delete or a user to delete messages from!",
                "type:invalid": "Please either specify a message count or user at position 1!",
                "number:range": "The message count must be a number between 0 to 100"
            },
            number: {
                min: 0,
                max: 100
            },
            optional: true
        },
        {
            types: [ArgumentType.Integer],
            optional: true,
            name: "count",
            errors: {
                "type:invalid": "Please specify a valid message count at position 2!",
                "number:range": "The message count must be a number between 0 to 100"
            },
            number: {
                min: 0,
                max: 100
            }
        },
        {
            types: [ArgumentType.Channel],
            optional: true,
            entity: {
                notNull: true
            },
            errors: {
                "entity:null": "This channel does not exist! If it's an ID, make sure it's correct!",
                "type:invalid": "Please specify a valid text channel at position 3!"
            },
            name: "channel"
        }
    ];
    public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
    public readonly aliases = ["purge", "bulkdel", "bulkdelete", "bc", "hc", "ec", "nc", "mc"];

    public readonly description = "Clear messages in bulk.";
    public readonly detailedDescription =
        "This command clears messages in bulk, by user or by count or both. This operation may take some time to complete.";
    public readonly argumentSyntaxes = ["<count>", "<UserID|UserMention> [count]"];

    public readonly botRequiredPermissions = [PermissionsBitField.Flags.ManageMessages];

    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addUserOption(option => option.setName("user").setDescription("The user"))
        .addIntegerOption(option =>
            option.setName("count").setDescription("The amount of messages to delete").setMaxValue(100).setMinValue(2)
        )
        .addIntegerOption(option =>
            option.setName("offset").setDescription("The message count offset").setMaxValue(99).setMinValue(0)
        )
        .addChannelOption(option => option.setName("channel").setDescription("The channel where the messages will be deleted"))
        .addBooleanOption(option => option.setName("filter_bots").setDescription("Deletes messages from bots"))
        .addBooleanOption(option => option.setName("filter_users").setDescription("Deletes messages from human users only"))
        .addBooleanOption(option => option.setName("filter_new_users").setDescription("Deletes messages from new users"))
        .addBooleanOption(option => option.setName("filter_embeds").setDescription("Deletes messages that have embeds"))
        .addBooleanOption(option =>
            option.setName("filter_unverifed_bots").setDescription("Deletes messages from unverified bots")
        )
        .addStringOption(option =>
            option.setName("filter_pattern").setDescription("Deletes messages matching with this regex pattern")
        )
        .addStringOption(option =>
            option.setName("filter_pattern_flags").setDescription("Flags for the regex pattern. Defaults to 'g' (global)")
        );

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        const isPrimaryCommand = !context.isLegacy
            ? !!context.options.data.find(option => option.name.startsWith("filter_"))
            : context.argv[0].length > 2;

        let count: number | undefined = !context.isLegacy
            ? context.options.getInteger("count") ?? undefined
            : typeof context.parsedNamedArgs.countOrUser === "number"
            ? context.parsedNamedArgs.countOrUser
            : context.parsedNamedArgs.count;

        const offset = (!context.isLegacy ? context.options.getInteger("offset") : null) ?? 0;

        const user: User | undefined = !context.isLegacy
            ? context.options.getUser("user") ?? undefined
            : typeof context.parsedNamedArgs.countOrUser !== "number"
            ? context.parsedNamedArgs.countOrUser
            : undefined;

        if (!count && count !== 0 && !user) {
            if (isPrimaryCommand) {
                return {
                    __reply: true,
                    content: `${this.emoji(
                        "error"
                    )} Please specify a user or message count, otherwise the system cannot determine how many messages to delete!`
                };
            } else {
                count = 20;
            }
        }

        const channel: Channel | undefined = !context.isLegacy
            ? context.options.getChannel("channel") ?? undefined
            : context.parsedNamedArgs.channel ?? undefined;

        if (channel && !isTextableChannel(channel)) {
            return {
                __reply: true,
                content: `${this.emoji("error")} The given channel is not a text channel`
            };
        }

        if (message instanceof ChatInputCommandInteraction) {
            if (message.options.getString("filter_pattern_flags") && !message.options.getString("filter_pattern")) {
                await this.error(message, `Option \`filter_pattern\` must be present when \`filter_pattern_flags\` is set.`);
                return;
            }
        }

        if (user) {
            try {
                const member = message.guild!.members.cache.get(user.id) ?? (await message.guild!.members.fetch(user.id));

                if (!(await this.client.permissionManager.shouldModerate(member, message.member! as GuildMember))) {
                    await this.error(message, "You don't have permission to clear messages from this user!");
                    return;
                }
            } catch (e) {
                logError(e);
            }
        }

        if (message instanceof Message) {
            await message.delete().catch(logError);
        }

        await this.deferIfInteraction(message, {
            ephemeral: true
        });

        const filterHandlers = [];

        if (message instanceof ChatInputCommandInteraction) {
            for (const option of message.options.data) {
                if (!option.name.startsWith("filter_") || !option.value) {
                    continue;
                }

                const filter = filters[option.name.replace("filter_", "") as keyof typeof filters];

                if (filter) {
                    filterHandlers.push(filter);
                } else {
                    if (option.name === "filter_pattern" && message.options.getString("filter_pattern")) {
                        try {
                            const regex = new RegExp(
                                message.options.getString("filter_pattern", true),
                                message.options.getString("filter_pattern_flags") ?? "g"
                            );

                            filterHandlers.push((message: Message) => regex.test(message.content));
                        } catch (e) {
                            logError(e);
                            await this.error(message, "Invalid flag(s) supplied for the regex pattern");
                            return;
                        }
                    }
                }
            }
        } else if (context.isLegacy) {
            const aliasHandlerName = filter_aliases[context.argv[0]];

            if (aliasHandlerName) {
                const aliasHandler = filters[aliasHandlerName];

                if (aliasHandler) {
                    filterHandlers.push(aliasHandler);
                }
            }
        }

        await this.client.infractionManager.bulkDeleteMessages({
            user,
            guild: message.guild!,
            reason: undefined,
            sendLog: true,
            moderator: message.member!.user as User,
            notifyUser: false,
            messageChannel: message.channel! as TextChannel,
            count,
            offset,
            filters: filterHandlers
        });

        if (message instanceof ChatInputCommandInteraction)
            await message.editReply(`${this.emoji("check")} Operation completed.`);
    }
}
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			Channel,
22			ChatInputCommandInteraction,
23			GuildMember,
24			Message,
25			PermissionsBitField,
26			SlashCommandBuilder,
27			TextChannel,
28			User
29			} from "discord.js";
30			import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
31			import { logError } from "../../utils/logger";
32			import { isTextableChannel } from "../../utils/utils";
33
34			const THREE_DAYS = 1000 * 60 * 60 * 24 * 3;
35
36			const filters = {
37			bots: (message: Message) => message.author.bot,
38			mentions: (message: Message) => /<(@!?\|#\|@&)\d+>/.test(message.content),
39			unverified_bots: (message: Message) => message.author.bot && !message.author.flags?.has("VerifiedBot"),
40			users: (message: Message) => !message.author.bot,
41			new_users: (message: Message) => !message.author.bot && message.createdAt.getTime() <= THREE_DAYS,
42			embeds: (message: Message) => message.embeds.length > 0
43			};
44
45			const filter_aliases: Record<string, keyof typeof filters> = {
46			bc: "bots",
47			hc: "users",
48			ec: "embeds",
49			nc: "new_users",
50			mc: "mentions"
51			};
52
53			export default class ClearCommand extends Command {
54			public readonly name = "clear";
55			public readonly validationRules: ValidationRule[] = [
56			{
57			types: [ArgumentType.User, ArgumentType.Integer],
58			entity: {
59			notNull: true
60			},
61			name: "countOrUser", // TODO: Be sure to support multiple names for the same argument [User, Integer] -> ['user', 'count'] = [User, 10]
62			errors: {
63			"entity:null": "This user does not exist! If it's an ID, make sure it's correct!",
64			required: "You must specify the count of messages to delete or a user to delete messages from!",
65			"type:invalid": "Please either specify a message count or user at position 1!",
66			"number:range": "The message count must be a number between 0 to 100"
67			},
68			number: {
69			min: 0,
70			max: 100
71			},
72			optional: true
73			},
74			{
75			types: [ArgumentType.Integer],
76			optional: true,
77			name: "count",
78			errors: {
79			"type:invalid": "Please specify a valid message count at position 2!",
80			"number:range": "The message count must be a number between 0 to 100"
81			},
82			number: {
83			min: 0,
84			max: 100
85			}
86			},
87			{
88			types: [ArgumentType.Channel],
89			optional: true,
90			entity: {
91			notNull: true
92			},
93			errors: {
94			"entity:null": "This channel does not exist! If it's an ID, make sure it's correct!",
95			"type:invalid": "Please specify a valid text channel at position 3!"
96			},
97			name: "channel"
98			}
99			];
100			public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
101			public readonly aliases = ["purge", "bulkdel", "bulkdelete", "bc", "hc", "ec", "nc", "mc"];
102
103			public readonly description = "Clear messages in bulk.";
104			public readonly detailedDescription =
105			"This command clears messages in bulk, by user or by count or both. This operation may take some time to complete.";
106			public readonly argumentSyntaxes = ["<count>", "<UserID\|UserMention> [count]"];
107
108			public readonly botRequiredPermissions = [PermissionsBitField.Flags.ManageMessages];
109
110			public readonly slashCommandBuilder = new SlashCommandBuilder()
111			.addUserOption(option => option.setName("user").setDescription("The user"))
112			.addIntegerOption(option =>
113			option.setName("count").setDescription("The amount of messages to delete").setMaxValue(100).setMinValue(2)
114			)
115			.addIntegerOption(option =>
116			option.setName("offset").setDescription("The message count offset").setMaxValue(99).setMinValue(0)
117			)
118			.addChannelOption(option => option.setName("channel").setDescription("The channel where the messages will be deleted"))
119			.addBooleanOption(option => option.setName("filter_bots").setDescription("Deletes messages from bots"))
120			.addBooleanOption(option => option.setName("filter_users").setDescription("Deletes messages from human users only"))
121			.addBooleanOption(option => option.setName("filter_new_users").setDescription("Deletes messages from new users"))
122			.addBooleanOption(option => option.setName("filter_embeds").setDescription("Deletes messages that have embeds"))
123			.addBooleanOption(option =>
124			option.setName("filter_unverifed_bots").setDescription("Deletes messages from unverified bots")
125			)
126			.addStringOption(option =>
127			option.setName("filter_pattern").setDescription("Deletes messages matching with this regex pattern")
128			)
129			.addStringOption(option =>
130			option.setName("filter_pattern_flags").setDescription("Flags for the regex pattern. Defaults to 'g' (global)")
131			);
132
133			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
134			const isPrimaryCommand = !context.isLegacy
135			? !!context.options.data.find(option => option.name.startsWith("filter_"))
136			: context.argv[0].length > 2;
137
138			let count: number \| undefined = !context.isLegacy
139			? context.options.getInteger("count") ?? undefined
140			: typeof context.parsedNamedArgs.countOrUser === "number"
141			? context.parsedNamedArgs.countOrUser
142			: context.parsedNamedArgs.count;
143
144			const offset = (!context.isLegacy ? context.options.getInteger("offset") : null) ?? 0;
145
146			const user: User \| undefined = !context.isLegacy
147			? context.options.getUser("user") ?? undefined
148			: typeof context.parsedNamedArgs.countOrUser !== "number"
149			? context.parsedNamedArgs.countOrUser
150			: undefined;
151
152			if (!count && count !== 0 && !user) {
153			if (isPrimaryCommand) {
154			return {
155			__reply: true,
156			content: `${this.emoji(
157			"error"
158			)} Please specify a user or message count, otherwise the system cannot determine how many messages to delete!`
159			};
160			} else {
161			count = 20;
162			}
163			}
164
165			const channel: Channel \| undefined = !context.isLegacy
166			? context.options.getChannel("channel") ?? undefined
167			: context.parsedNamedArgs.channel ?? undefined;
168
169			if (channel && !isTextableChannel(channel)) {
170			return {
171			__reply: true,
172			content: `${this.emoji("error")} The given channel is not a text channel`
173			};
174			}
175
176			if (message instanceof ChatInputCommandInteraction) {
177			if (message.options.getString("filter_pattern_flags") && !message.options.getString("filter_pattern")) {
178			await this.error(message, `Option \`filter_pattern\` must be present when \`filter_pattern_flags\` is set.`);
179			return;
180			}
181			}
182
183			if (user) {
184			try {
185			const member = message.guild!.members.cache.get(user.id) ?? (await message.guild!.members.fetch(user.id));
186
187			if (!(await this.client.permissionManager.shouldModerate(member, message.member! as GuildMember))) {
188			await this.error(message, "You don't have permission to clear messages from this user!");
189			return;
190			}
191			} catch (e) {
192			logError(e);
193			}
194			}
195
196			if (message instanceof Message) {
197			await message.delete().catch(logError);
198			}
199
200			await this.deferIfInteraction(message, {
201			ephemeral: true
202			});
203
204			const filterHandlers = [];
205
206			if (message instanceof ChatInputCommandInteraction) {
207			for (const option of message.options.data) {
208			if (!option.name.startsWith("filter_") \|\| !option.value) {
209			continue;
210			}
211
212			const filter = filters[option.name.replace("filter_", "") as keyof typeof filters];
213
214			if (filter) {
215			filterHandlers.push(filter);
216			} else {
217			if (option.name === "filter_pattern" && message.options.getString("filter_pattern")) {
218			try {
219			const regex = new RegExp(
220			message.options.getString("filter_pattern", true),
221			message.options.getString("filter_pattern_flags") ?? "g"
222			);
223
224			filterHandlers.push((message: Message) => regex.test(message.content));
225			} catch (e) {
226			logError(e);
227			await this.error(message, "Invalid flag(s) supplied for the regex pattern");
228			return;
229			}
230			}
231			}
232			}
233			} else if (context.isLegacy) {
234			const aliasHandlerName = filter_aliases[context.argv[0]];
235
236			if (aliasHandlerName) {
237			const aliasHandler = filters[aliasHandlerName];
238
239			if (aliasHandler) {
240			filterHandlers.push(aliasHandler);
241			}
242			}
243			}
244
245			await this.client.infractionManager.bulkDeleteMessages({
246			user,
247			guild: message.guild!,
248			reason: undefined,
249			sendLog: true,
250			moderator: message.member!.user as User,
251			notifyUser: false,
252			messageChannel: message.channel! as TextChannel,
253			count,
254			offset,
255			filters: filterHandlers
256			});
257
258			if (message instanceof ChatInputCommandInteraction)
259			await message.editReply(`${this.emoji("check")} Operation completed.`);
260			}
261			}