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