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	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 { 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			}