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")
        )
        .addStringOption(option =>
            option.setName("reason").setDescription("The reason for deleting the messages")
        )
        .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:
                message instanceof ChatInputCommandInteraction
                    ? message.options.getString("reason") ?? undefined
                    : undefined,
            sendLog: true,
            moderator: message.member!.user as User,
            notifyUser: false,
            messageChannel: message.channel! as TextChannel,
            count,
            offset,
            filters: filterHandlers,
            abortOnTemplateNotFound: true
        });

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