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