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";

export default class ClearCommand extends Command {
    public readonly name = "clear";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.User, ArgumentType.Integer],
            entityNotNull: true,
            entityNotNullErrorMessage: "This user does not exist! If it's an ID, make sure it's correct!",
            name: "countOrUser",
            requiredErrorMessage: "You must specify the count of messages to delete or a user to delete messages from!",
            typeErrorMessage: "Please either specify a message count or user at position 1!",
            minValue: 0,
            maxValue: 100,
            minMaxErrorMessage: "The message count must be a number between 0 to 100"
        },
        {
            types: [ArgumentType.Integer],
            optional: true,
            name: "count",
            typeErrorMessage: "Please specify a valid message count at position 2!",
            minValue: 0,
            maxValue: 100,
            minMaxErrorMessage: "The message count must be a number between 0 to 100"
        },
        {
            types: [ArgumentType.Channel],
            optional: true,
            entityNotNull: true,
            entityNotNullErrorMessage: "This channel does not exist! If it's an ID, make sure it's correct!",
            name: "channel",
            typeErrorMessage: "Please specify a valid text channel at position 3!"
        }
    ];
    public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
    public readonly aliases = ["purge", "bulkdel", "bulkdelete"];

    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))
        .addChannelOption(option => option.setName("channel").setDescription("The channel where the messages will be deleted"));

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        const count: number | undefined = !context.isLegacy
            ? context.options.getInteger("count") ?? undefined
            : typeof context.parsedNamedArgs.countOrUser === "number"
            ? context.parsedNamedArgs.countOrUser
            : context.parsedNamedArgs.count;

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

        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 (!count && count !== 0 && !user) {
            return {
                __reply: true,
                content: `${this.emoji(
                    "error"
                )} Please specify a user or message count, otherwise the system cannot determine how many messages to delete!`
            };
        }

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

                if (!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);

        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
        });

        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 { Channel, ChatInputCommandInteraction, GuildMember, Message, PermissionsBitField, SlashCommandBuilder, TextChannel, User } from "discord.js";
21	import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
22	import { logError } from "../../utils/logger";
23	import { isTextableChannel } from "../../utils/utils";
24
25	export default class ClearCommand extends Command {
26	public readonly name = "clear";
27	public readonly validationRules: ValidationRule[] = [
28	{
29	types: [ArgumentType.User, ArgumentType.Integer],
30	entityNotNull: true,
31	entityNotNullErrorMessage: "This user does not exist! If it's an ID, make sure it's correct!",
32	name: "countOrUser",
33	requiredErrorMessage: "You must specify the count of messages to delete or a user to delete messages from!",
34	typeErrorMessage: "Please either specify a message count or user at position 1!",
35	minValue: 0,
36	maxValue: 100,
37	minMaxErrorMessage: "The message count must be a number between 0 to 100"
38	},
39	{
40	types: [ArgumentType.Integer],
41	optional: true,
42	name: "count",
43	typeErrorMessage: "Please specify a valid message count at position 2!",
44	minValue: 0,
45	maxValue: 100,
46	minMaxErrorMessage: "The message count must be a number between 0 to 100"
47	},
48	{
49	types: [ArgumentType.Channel],
50	optional: true,
51	entityNotNull: true,
52	entityNotNullErrorMessage: "This channel does not exist! If it's an ID, make sure it's correct!",
53	name: "channel",
54	typeErrorMessage: "Please specify a valid text channel at position 3!"
55	}
56	];
57	public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
58	public readonly aliases = ["purge", "bulkdel", "bulkdelete"];
59
60	public readonly description = "Clear messages in bulk.";
61	public readonly detailedDescription =
62	"This command clears messages in bulk, by user or by count or both. This operation may take some time to complete.";
63	public readonly argumentSyntaxes = ["<count>", "<UserID\|UserMention> [count]"];
64
65	public readonly botRequiredPermissions = [PermissionsBitField.Flags.ManageMessages];
66
67	public readonly slashCommandBuilder = new SlashCommandBuilder()
68	.addUserOption(option => option.setName("user").setDescription("The user"))
69	.addIntegerOption(option => option.setName("count").setDescription("The amount of messages to delete").setMaxValue(100).setMinValue(2))
70	.addChannelOption(option => option.setName("channel").setDescription("The channel where the messages will be deleted"));
71
72	async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
73	const count: number \| undefined = !context.isLegacy
74	? context.options.getInteger("count") ?? undefined
75	: typeof context.parsedNamedArgs.countOrUser === "number"
76	? context.parsedNamedArgs.countOrUser
77	: context.parsedNamedArgs.count;
78
79	const user: User \| undefined = !context.isLegacy
80	? context.options.getUser("user") ?? undefined
81	: typeof context.parsedNamedArgs.countOrUser !== "number"
82	? context.parsedNamedArgs.countOrUser
83	: undefined;
84
85	const channel: Channel \| undefined = !context.isLegacy
86	? context.options.getChannel("channel") ?? undefined
87	: context.parsedNamedArgs.channel ?? undefined;
88
89	if (channel && !isTextableChannel(channel)) {
90	return {
91	__reply: true,
92	content: `${this.emoji("error")} The given channel is not a text channel`
93	};
94	}
95
96	if (!count && count !== 0 && !user) {
97	return {
98	__reply: true,
99	content: `${this.emoji(
100	"error"
101	)} Please specify a user or message count, otherwise the system cannot determine how many messages to delete!`
102	};
103	}
104
105	if (user) {
106	try {
107	const member = message.guild!.members.cache.get(user.id) ?? (await message.guild!.members.fetch(user.id));
108
109	if (!this.client.permissionManager.shouldModerate(member, message.member! as GuildMember)) {
110	await this.error(message, "You don't have permission to clear messages from this user!");
111	return;
112	}
113	} catch (e) {
114	logError(e);
115	}
116	}
117
118	if (message instanceof Message) {
119	await message.delete().catch(logError);
120	}
121
122	await this.deferIfInteraction(message);
123
124	await this.client.infractionManager.bulkDeleteMessages({
125	user,
126	guild: message.guild!,
127	reason: undefined,
128	sendLog: true,
129	moderator: message.member!.user as User,
130	notifyUser: false,
131	messageChannel: message.channel! as TextChannel,
132	count
133	});
134
135	if (message instanceof ChatInputCommandInteraction) await message.editReply(`${this.emoji("check")} Operation completed.`);
136	}
137	}