commands/moderation/MassBanCommand.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* 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 { BanOptions, CommandInteraction, Message, User, Permissions } from 'discord.js';
import BaseCommand from '../../utils/structures/BaseCommand';
import DiscordClient from '../../client/Client';
import CommandOptions from '../../types/CommandOptions';
import InteractionOptions from '../../types/InteractionOptions';
import MessageEmbed from '../../client/MessageEmbed';
import { fetchEmoji } from '../../utils/Emoji';
import Punishment from '../../models/Punishment';
import PunishmentType from '../../types/PunishmentType';
import { hasPermission, shouldNotModerate } from '../../utils/util';

export default class MassBanCommand extends BaseCommand {
    supportsInteractions: boolean = true;
    
    permissions = [Permissions.FLAGS.BAN_MEMBERS];

    constructor() {
        super('massban', 'moderation', []);
    }

    async run(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[0] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires at least one argument.`)
                ]
            });

            return;
        }

        if (msg instanceof CommandInteraction)
            await msg.deferReply();

        let arr: (string | User)[] = [];
        let reasonStart = false;
        let banOptions: BanOptions = {};

        if (options.isInteraction) {
            arr = (<string> options.options.getString('users')).split(' ');

            if (options.options.getString('reason'))
                banOptions.reason = <string> options.options.getString('reason');

            if (options.options.getInteger('days'))
                banOptions.days = <number> options.options.getInteger('days');
        }
        else {
            let i = 0;

            for await (const arg of options.args) {
                if (!/^\d+$/g.test(arg) && !(arg.startsWith('<@') && arg.endsWith('>'))) {
                    reasonStart = true;
                }

                if (reasonStart) {
                    banOptions.reason = banOptions.reason ?? '';
                    banOptions.reason += arg + ' ';
                }
                else {
                    if (/^\d+$/g.test(arg)) {
                        arr.push(arg);
                    }
                    else if ((msg as Message).mentions.users.at(i)) {
                        arr.push((msg as Message).mentions.users.at(i)! as User);
                        console.log((msg as Message).mentions.users.at(i)!);
                        
                        i++;
                    }
                }
            }

            if (banOptions.reason) {
                banOptions.reason = banOptions.reason.trim();
            }
        }

        if (arr.length < 1) {
            await this.deferReply(msg, {
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`Invalid user(s) given.`)
                ]
            });

            return;
        }

        let usersStr = '';

        for await (const uid of arr) {
            try {
                console.log(uid);
                
                const user = typeof uid === 'string' ? await client.users.fetch(uid) : uid;

                try {
                    console.log(banOptions.reason);

                    try {
                        const member = await msg.guild?.members.fetch(user.id);

                        if (member && !(await hasPermission(client, member, msg, null, "You don't have permission to ban " + user.tag + ".")))
                            break;
                            
                        if (member && shouldNotModerate(client, member)) {
                            await msg.reply({
                                embeds: [
                                    new MessageEmbed()
                                    .setColor('#f14a60')
                                    .setDescription('The user ' + user.tag + ' is not bannable.')
                                ]
                            });

                            return;
                        }
                    }
                    catch (e) {
                        console.log(e);
                    }

                    await Punishment.create({
                        type: PunishmentType.BAN,
                        user_id: user.id,
                        guild_id: msg.guild!.id,
                        mod_id: msg.member!.user.id,
                        mod_tag: (msg.member!.user as User).tag,
                        reason: banOptions.reason ?? undefined,
                        createdAt: new Date()
                    });

                    await msg.guild!.bans.create(user, banOptions);
                    
                    usersStr += user.tag + ' (' + user.id + ')\n';
                }
                catch (e) {
                    console.log(e);
                
                    await this.deferReply(msg, {
                        content: 'Failed to ban ' + user.tag + ' (' + user.id + ').'
                    });

                    return;
                }
            }
            catch (e) {
                console.log(e);
                
                await this.deferReply(msg, {
                    content: 'Invalid ID(s) given. (' + uid.toString() + ')'
                });

                return;
            }
        }

        await this.deferReply(msg, {
            embeds: [
                new MessageEmbed()
                .setAuthor({
                    name: 'Mass Ban'
                })
                .setDescription(`${(await fetchEmoji('check'))?.toString()} Mass banned the following users:\n\n${usersStr}`)
                .addField('Reason', banOptions.reason ?? '*No reason provided*')
            ]
        });
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2022 OSN Inc.
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 { BanOptions, CommandInteraction, Message, User, Permissions } from 'discord.js';
21	import BaseCommand from '../../utils/structures/BaseCommand';
22	import DiscordClient from '../../client/Client';
23	import CommandOptions from '../../types/CommandOptions';
24	import InteractionOptions from '../../types/InteractionOptions';
25	import MessageEmbed from '../../client/MessageEmbed';
26	import { fetchEmoji } from '../../utils/Emoji';
27	import Punishment from '../../models/Punishment';
28	import PunishmentType from '../../types/PunishmentType';
29	import { hasPermission, shouldNotModerate } from '../../utils/util';
30
31	export default class MassBanCommand extends BaseCommand {
32	supportsInteractions: boolean = true;
33
34	permissions = [Permissions.FLAGS.BAN_MEMBERS];
35
36	constructor() {
37	super('massban', 'moderation', []);
38	}
39
40	async run(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
41	if (!options.isInteraction && typeof options.args[0] === 'undefined') {
42	await msg.reply({
43	embeds: [
44	new MessageEmbed()
45	.setColor('#f14a60')
46	.setDescription(`This command requires at least one argument.`)
47	]
48	});
49
50	return;
51	}
52
53	if (msg instanceof CommandInteraction)
54	await msg.deferReply();
55
56	let arr: (string \| User)[] = [];
57	let reasonStart = false;
58	let banOptions: BanOptions = {};
59
60	if (options.isInteraction) {
61	arr = (<string> options.options.getString('users')).split(' ');
62
63	if (options.options.getString('reason'))
64	banOptions.reason = <string> options.options.getString('reason');
65
66	if (options.options.getInteger('days'))
67	banOptions.days = <number> options.options.getInteger('days');
68	}
69	else {
70	let i = 0;
71
72	for await (const arg of options.args) {
73	if (!/^\d+$/g.test(arg) && !(arg.startsWith('<@') && arg.endsWith('>'))) {
74	reasonStart = true;
75	}
76
77	if (reasonStart) {
78	banOptions.reason = banOptions.reason ?? '';
79	banOptions.reason += arg + ' ';
80	}
81	else {
82	if (/^\d+$/g.test(arg)) {
83	arr.push(arg);
84	}
85	else if ((msg as Message).mentions.users.at(i)) {
86	arr.push((msg as Message).mentions.users.at(i)! as User);
87	console.log((msg as Message).mentions.users.at(i)!);
88
89	i++;
90	}
91	}
92	}
93
94	if (banOptions.reason) {
95	banOptions.reason = banOptions.reason.trim();
96	}
97	}
98
99	if (arr.length < 1) {
100	await this.deferReply(msg, {
101	embeds: [
102	new MessageEmbed()
103	.setColor('#f14a60')
104	.setDescription(`Invalid user(s) given.`)
105	]
106	});
107
108	return;
109	}
110
111	let usersStr = '';
112
113	for await (const uid of arr) {
114	try {
115	console.log(uid);
116
117	const user = typeof uid === 'string' ? await client.users.fetch(uid) : uid;
118
119	try {
120	console.log(banOptions.reason);
121
122	try {
123	const member = await msg.guild?.members.fetch(user.id);
124
125	if (member && !(await hasPermission(client, member, msg, null, "You don't have permission to ban " + user.tag + ".")))
126	break;
127
128	if (member && shouldNotModerate(client, member)) {
129	await msg.reply({
130	embeds: [
131	new MessageEmbed()
132	.setColor('#f14a60')
133	.setDescription('The user ' + user.tag + ' is not bannable.')
134	]
135	});
136
137	return;
138	}
139	}
140	catch (e) {
141	console.log(e);
142	}
143
144	await Punishment.create({
145	type: PunishmentType.BAN,
146	user_id: user.id,
147	guild_id: msg.guild!.id,
148	mod_id: msg.member!.user.id,
149	mod_tag: (msg.member!.user as User).tag,
150	reason: banOptions.reason ?? undefined,
151	createdAt: new Date()
152	});
153
154	await msg.guild!.bans.create(user, banOptions);
155
156	usersStr += user.tag + ' (' + user.id + ')\n';
157	}
158	catch (e) {
159	console.log(e);
160
161	await this.deferReply(msg, {
162	content: 'Failed to ban ' + user.tag + ' (' + user.id + ').'
163	});
164
165	return;
166	}
167	}
168	catch (e) {
169	console.log(e);
170
171	await this.deferReply(msg, {
172	content: 'Invalid ID(s) given. (' + uid.toString() + ')'
173	});
174
175	return;
176	}
177	}
178
179	await this.deferReply(msg, {
180	embeds: [
181	new MessageEmbed()
182	.setAuthor({
183	name: 'Mass Ban'
184	})
185	.setDescription(`${(await fetchEmoji('check'))?.toString()} Mass banned the following users:\n\n${usersStr}`)
186	.addField('Reason', banOptions.reason ?? 'No reason provided')
187	]
188	});
189	}
190	}