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	rakinar2	577	/**
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			}