commands/moderation/MassBanCommand.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 { GuildMember, PermissionsBitField, SlashCommandBuilder, User } from "discord.js";
import Command, {
    BasicCommandContext,
    CommandMessage,
    CommandReturn,
    ValidationRule
} from "../../core/Command";
import { log, logError } from "../../utils/Logger";
import { stringToTimeInterval } from "../../utils/datetime";
import { isSnowflake } from "../../utils/utils";

export default class MassBanCommand extends Command {
    public readonly name = "massban";
    public readonly validationRules: ValidationRule[] = [];
    public readonly permissions = [PermissionsBitField.Flags.Administrator];
    public readonly aliases = ["mban"];

    public readonly description = "Ban multiple users at the same time.";
    public readonly detailedDescription =
        "This command can ban multiple users. This is helpful if you want to quickly ban server raiders. The message deletion timeframe is 7 days by default.";
    public readonly argumentSyntaxes = ["<...UserIDs|UserMentions> [Reason]"];

    public readonly botRequiredPermissions = [PermissionsBitField.Flags.Administrator];

    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addUserOption(option =>
            option.setName("users").setDescription("The users to ban").setRequired(true)
        )
        .addStringOption(option =>
            option.setName("reason").setDescription("The reason for taking this action")
        )
        .addStringOption(option =>
            option
                .setName("deletion_timeframe")
                .setDescription("The message deletion timeframe (must be in range 0-604800)")
        );

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        if (context.isLegacy && context.args[0] === undefined) {
            return {
                __reply: true,
                content: `${this.emoji("error")} Please specify at least 1 user to ban!`
            };
        }

        const args = context.isLegacy
            ? context.args
            : context.options.getString("users", true).split(/ +/);

        if (args.length > 20) {
            return {
                __reply: true,
                content: `${this.emoji("error")} Cannot massban more than 20 users at once!`
            };
        }

        const users: string[] = [];
        let position = 0;

        for (const arg of args) {
            let id: string | undefined = undefined;

            if (isSnowflake(arg)) {
                id = arg;
            } else if (arg.startsWith("<@") && arg.endsWith(">")) {
                id = arg.substring(arg.includes("!") ? 3 : 2, arg.length - 1);
            }

            if (id && !isSnowflake(id)) {
                return {
                    __reply: true,
                    content: `\`${id}\` is not a valid user mention format or the ID is incorrect.`
                };
            }

            if (!id) break;

            users.push(id);
            position++;
        }

        await this.deferIfInteraction(message);

        let reason = context.isLegacy
            ? undefined
            : context.options.getString("reason") ?? undefined;
        let deleteMessageSeconds = context.isLegacy ? 604800 : undefined;

        ifContextIsNotLegacy: if (!context.isLegacy) {
            const input = context.options.getString("deletion_timeframe");

            if (!input) break ifContextIsNotLegacy;

            const { result, error } = stringToTimeInterval(input);

            if (error) {
                await this.deferredReply(message, {
                    content: `${this.emoji(
                        "error"
                    )} ${error} provided in the \`deletion_timeframe\` option`
                });

                return;
            }

            if (result < 0 || result > 604800) {
                await this.deferredReply(
                    message,
                    `${this.emoji(
                        "error"
                    )} The message deletion range must be a time interval from 0 second to 604800 seconds (7 days).`
                );
                return;
            }

            deleteMessageSeconds = result;
        }

        if (context.isLegacy) {
            reason = "";

            for (; position < args.length; position++) {
                reason += args[position] + " ";
            }

            reason = reason.trimEnd();
        }

        for (const user of users) {
            try {
                const member =
                    message.guild!.members.cache.get(user) ??
                    (await message.guild!.members.fetch(user));

                log("Fetched member to check permissions");

                if (
                    !(await this.client.permissionManager.shouldModerate(
                        member,
                        message.member! as GuildMember
                    ))
                ) {
                    await this.deferredReply(message, {
                        content: `${this.emoji(
                            "error"
                        )} You don't have permission to ban ${member.user.toString()}!`,
                        allowedMentions: {
                            users: []
                        }
                    });

                    return;
                }
            } catch (e) {
                logError(e);
            }
        }

        const reply = await this.deferredReply(message, {
            content: `${this.emoji("loading")} Preparing to ban ${users.length} users...`
        });

        await this.client.infractionManager.createUserMassBan({
            users,
            moderator: message.member!.user as User,
            reason: reason?.trim() === "" ? undefined : reason,
            sendLog: true,
            guild: message.guild!,
            deleteMessageSeconds,
            callAfterEach: 10,
            abortOnTemplateNotFound: true,
            callback: async ({ completedUsers, skippedUsers, users, completedIn }) => {
                log(
                    `Banned ${completedUsers.length} out of ${users.length} users (${skippedUsers.length} failed)`
                );

                await reply
                    .edit({
                        content: `${this.emoji(
                            completedUsers.length === users.length && completedIn
                                ? "check"
                                : "loading"
                        )} Banned ${completedUsers.length} out of ${users.length} users (${
                            completedIn ? `Completed in ${completedIn}s, ` : ""
                        }${skippedUsers.length} failures)`
                    })
                    .catch(logError);
            }
        });
    }
}
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 { GuildMember, PermissionsBitField, SlashCommandBuilder, User } from "discord.js";
21			import Command, {
22			BasicCommandContext,
23			CommandMessage,
24			CommandReturn,
25			ValidationRule
26			} from "../../core/Command";
27			import { log, logError } from "../../utils/Logger";
28			import { stringToTimeInterval } from "../../utils/datetime";
29			import { isSnowflake } from "../../utils/utils";
30
31			export default class MassBanCommand extends Command {
32			public readonly name = "massban";
33			public readonly validationRules: ValidationRule[] = [];
34			public readonly permissions = [PermissionsBitField.Flags.Administrator];
35			public readonly aliases = ["mban"];
36
37			public readonly description = "Ban multiple users at the same time.";
38			public readonly detailedDescription =
39			"This command can ban multiple users. This is helpful if you want to quickly ban server raiders. The message deletion timeframe is 7 days by default.";
40			public readonly argumentSyntaxes = ["<...UserIDs\|UserMentions> [Reason]"];
41
42			public readonly botRequiredPermissions = [PermissionsBitField.Flags.Administrator];
43
44			public readonly slashCommandBuilder = new SlashCommandBuilder()
45			.addUserOption(option =>
46			option.setName("users").setDescription("The users to ban").setRequired(true)
47			)
48			.addStringOption(option =>
49			option.setName("reason").setDescription("The reason for taking this action")
50			)
51			.addStringOption(option =>
52			option
53			.setName("deletion_timeframe")
54			.setDescription("The message deletion timeframe (must be in range 0-604800)")
55			);
56
57			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
58			if (context.isLegacy && context.args[0] === undefined) {
59			return {
60			__reply: true,
61			content: `${this.emoji("error")} Please specify at least 1 user to ban!`
62			};
63			}
64
65			const args = context.isLegacy
66			? context.args
67			: context.options.getString("users", true).split(/ +/);
68
69			if (args.length > 20) {
70			return {
71			__reply: true,
72			content: `${this.emoji("error")} Cannot massban more than 20 users at once!`
73			};
74			}
75
76			const users: string[] = [];
77			let position = 0;
78
79			for (const arg of args) {
80			let id: string \| undefined = undefined;
81
82			if (isSnowflake(arg)) {
83			id = arg;
84			} else if (arg.startsWith("<@") && arg.endsWith(">")) {
85			id = arg.substring(arg.includes("!") ? 3 : 2, arg.length - 1);
86			}
87
88			if (id && !isSnowflake(id)) {
89			return {
90			__reply: true,
91			content: `\`${id}\` is not a valid user mention format or the ID is incorrect.`
92			};
93			}
94
95			if (!id) break;
96
97			users.push(id);
98			position++;
99			}
100
101			await this.deferIfInteraction(message);
102
103			let reason = context.isLegacy
104			? undefined
105			: context.options.getString("reason") ?? undefined;
106			let deleteMessageSeconds = context.isLegacy ? 604800 : undefined;
107
108			ifContextIsNotLegacy: if (!context.isLegacy) {
109			const input = context.options.getString("deletion_timeframe");
110
111			if (!input) break ifContextIsNotLegacy;
112
113			const { result, error } = stringToTimeInterval(input);
114
115			if (error) {
116			await this.deferredReply(message, {
117			content: `${this.emoji(
118			"error"
119			)} ${error} provided in the \`deletion_timeframe\` option`
120			});
121
122			return;
123			}
124
125			if (result < 0 \|\| result > 604800) {
126			await this.deferredReply(
127			message,
128			`${this.emoji(
129			"error"
130			)} The message deletion range must be a time interval from 0 second to 604800 seconds (7 days).`
131			);
132			return;
133			}
134
135			deleteMessageSeconds = result;
136			}
137
138			if (context.isLegacy) {
139			reason = "";
140
141			for (; position < args.length; position++) {
142			reason += args[position] + " ";
143			}
144
145			reason = reason.trimEnd();
146			}
147
148			for (const user of users) {
149			try {
150			const member =
151			message.guild!.members.cache.get(user) ??
152			(await message.guild!.members.fetch(user));
153
154			log("Fetched member to check permissions");
155
156			if (
157			!(await this.client.permissionManager.shouldModerate(
158			member,
159			message.member! as GuildMember
160			))
161			) {
162			await this.deferredReply(message, {
163			content: `${this.emoji(
164			"error"
165			)} You don't have permission to ban ${member.user.toString()}!`,
166			allowedMentions: {
167			users: []
168			}
169			});
170
171			return;
172			}
173			} catch (e) {
174			logError(e);
175			}
176			}
177
178			const reply = await this.deferredReply(message, {
179			content: `${this.emoji("loading")} Preparing to ban ${users.length} users...`
180			});
181
182			await this.client.infractionManager.createUserMassBan({
183			users,
184			moderator: message.member!.user as User,
185			reason: reason?.trim() === "" ? undefined : reason,
186			sendLog: true,
187			guild: message.guild!,
188			deleteMessageSeconds,
189			callAfterEach: 10,
190			abortOnTemplateNotFound: true,
191			callback: async ({ completedUsers, skippedUsers, users, completedIn }) => {
192			log(
193			`Banned ${completedUsers.length} out of ${users.length} users (${skippedUsers.length} failed)`
194			);
195
196			await reply
197			.edit({
198			content: `${this.emoji(
199			completedUsers.length === users.length && completedIn
200			? "check"
201			: "loading"
202			)} Banned ${completedUsers.length} out of ${users.length} users (${
203			completedIn ? `Completed in ${completedIn}s, ` : ""
204			}${skippedUsers.length} failures)`
205			})
206			.catch(logError);
207			}
208			});
209			}
210			}