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