commands/moderation/SoftBanCommand.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 getUser from '../../utils/getUser';
import Punishment from '../../models/Punishment';
import PunishmentType from '../../types/PunishmentType';
import { fetchEmojiStr } from '../../utils/Emoji';
import { hasPermission, shouldNotModerate } from '../../utils/util';

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

    constructor() {
        super('softban', '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;
        }

        let user: User;
        let banOptions: BanOptions = {
            days: 7
        };

        if (options.isInteraction) {
            user = await <User> options.options.getUser('user');

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

            if (options.options.getInteger('days')) {
                banOptions.days = await <number> options.options.getInteger('days');
            }
        }
        else {
            const user2 = await getUser(client, (msg as Message), options);

            if (!user2) {
                await msg.reply({
                    embeds: [
                        new MessageEmbed()
                        .setColor('#f14a60')
                        .setDescription(`Invalid user given.`)
                    ]
                });
    
                return;
            }

            user = user2;

            const index = await options.args.indexOf('-d');

            if (options.args[1]) {
                const args = [...options.args];
                args.shift();

                if (index !== -1) {
                    args.splice(index - 1, 2)
                }

                banOptions.reason = await args.join(' ');
            }

            if (index !== -1) {
                const days = await options.args[index + 1];

                if (days === undefined) {
                    await msg.reply({
                        embeds: [
                            new MessageEmbed()
                            .setColor('#f14a60')
                            .setDescription(`Option \`-d\` (days) requires an argument.`)
                        ]
                    });
        
                    return;
                }

                if (!parseInt(days) || parseInt(days) < 0 || parseInt(days) > 7) {
                    await msg.reply({
                        embeds: [
                            new MessageEmbed()
                            .setColor('#f14a60')
                            .setDescription(`Option \`-d\` (days) requires an argument which must be a valid number and in range of 0-7.`)
                        ]
                    });
        
                    return;
                }

                banOptions.days = await parseInt(days);
            }
        }
        
        let reply = await msg.reply({
            embeds: [
                new MessageEmbed({
                    author: {
                        name: user.tag,
                        iconURL: user.displayAvatarURL()
                    },
                    description: `${await fetchEmojiStr('loading')} Softban is in progress...`,
                    color: 'GOLD'
                })
            ]
        });
        
        if (msg instanceof CommandInteraction)
            reply = <Message> await msg.fetchReply();

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

                if (member && !(await hasPermission(client, member, msg, null, "You don't have permission to softban this user."))) {
                    return;
                }

                if (member && shouldNotModerate(client, member)) {
                    await msg.reply({
                        embeds: [
                            new MessageEmbed()
                            .setColor('#f14a60')
                            .setDescription('This user cannot be softbanned.')
                        ]
                    });

                    return;
                }
            }
            catch (e) {
                console.log(e);
            }
            
            await msg.guild?.bans.create(user, banOptions);
            await new Promise(r => setTimeout(r, 1600));
            await msg.guild?.bans.remove(user);

            const punishment = await Punishment.create({
                type: PunishmentType.SOFTBAN,
                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,
                meta: {
                    days: banOptions.days
                },
                createdAt: new Date()
            });

            await client.logger.logSoftBan(banOptions, msg.guild!, user, punishment);

            await reply!.edit({
                embeds: [
                    new MessageEmbed({
                        author: {
                            name: user.tag,
                            iconURL: user.displayAvatarURL()
                        },
                        description: `${await fetchEmojiStr('check')} Softbanned user ${user.tag}`,
                        fields: [
                            {
                                name: 'Softbanned by',
                                value: (<User> msg.member?.user).tag
                            },
                            {
                                name: 'Reason',
                                value: banOptions.reason ?? '*No reason provided*'
                            }
                        ]
                    })
                ]
            });
        }
        catch (e) {
            await reply!.edit({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription("Failed to softban this user. Maybe missing permisions or I'm not allowed to ban this user?")
                ]
            });

            return;
        }
    }
}
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 getUser from '../../utils/getUser';
27			import Punishment from '../../models/Punishment';
28			import PunishmentType from '../../types/PunishmentType';
29			import { fetchEmojiStr } from '../../utils/Emoji';
30			import { hasPermission, shouldNotModerate } from '../../utils/util';
31
32			export default class SoftBanCommand extends BaseCommand {
33			supportsInteractions: boolean = true;
34			permissions = [Permissions.FLAGS.BAN_MEMBERS];
35
36			constructor() {
37			super('softban', '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			let user: User;
54			let banOptions: BanOptions = {
55			days: 7
56			};
57
58			if (options.isInteraction) {
59			user = await <User> options.options.getUser('user');
60
61			if (options.options.getString('reason')) {
62			banOptions.reason = await <string> options.options.getString('reason');
63			}
64
65			if (options.options.getInteger('days')) {
66			banOptions.days = await <number> options.options.getInteger('days');
67			}
68			}
69			else {
70			const user2 = await getUser(client, (msg as Message), options);
71
72			if (!user2) {
73			await msg.reply({
74			embeds: [
75			new MessageEmbed()
76			.setColor('#f14a60')
77			.setDescription(`Invalid user given.`)
78			]
79			});
80
81			return;
82			}
83
84			user = user2;
85
86			const index = await options.args.indexOf('-d');
87
88			if (options.args[1]) {
89			const args = [...options.args];
90			args.shift();
91
92			if (index !== -1) {
93			args.splice(index - 1, 2)
94			}
95
96			banOptions.reason = await args.join(' ');
97			}
98
99			if (index !== -1) {
100			const days = await options.args[index + 1];
101
102			if (days === undefined) {
103			await msg.reply({
104			embeds: [
105			new MessageEmbed()
106			.setColor('#f14a60')
107			.setDescription(`Option \`-d\` (days) requires an argument.`)
108			]
109			});
110
111			return;
112			}
113
114			if (!parseInt(days) \|\| parseInt(days) < 0 \|\| parseInt(days) > 7) {
115			await msg.reply({
116			embeds: [
117			new MessageEmbed()
118			.setColor('#f14a60')
119			.setDescription(`Option \`-d\` (days) requires an argument which must be a valid number and in range of 0-7.`)
120			]
121			});
122
123			return;
124			}
125
126			banOptions.days = await parseInt(days);
127			}
128			}
129
130			let reply = await msg.reply({
131			embeds: [
132			new MessageEmbed({
133			author: {
134			name: user.tag,
135			iconURL: user.displayAvatarURL()
136			},
137			description: `${await fetchEmojiStr('loading')} Softban is in progress...`,
138			color: 'GOLD'
139			})
140			]
141			});
142
143			if (msg instanceof CommandInteraction)
144			reply = <Message> await msg.fetchReply();
145
146			try {
147			try {
148			const member = await msg.guild!.members.fetch(user.id);
149
150			if (member && !(await hasPermission(client, member, msg, null, "You don't have permission to softban this user."))) {
151			return;
152			}
153
154			if (member && shouldNotModerate(client, member)) {
155			await msg.reply({
156			embeds: [
157			new MessageEmbed()
158			.setColor('#f14a60')
159			.setDescription('This user cannot be softbanned.')
160			]
161			});
162
163			return;
164			}
165			}
166			catch (e) {
167			console.log(e);
168			}
169
170			await msg.guild?.bans.create(user, banOptions);
171			await new Promise(r => setTimeout(r, 1600));
172			await msg.guild?.bans.remove(user);
173
174			const punishment = await Punishment.create({
175			type: PunishmentType.SOFTBAN,
176			user_id: user.id,
177			guild_id: msg.guild!.id,
178			mod_id: msg.member!.user.id,
179			mod_tag: (msg.member!.user as User).tag,
180			reason: banOptions.reason ?? undefined,
181			meta: {
182			days: banOptions.days
183			},
184			createdAt: new Date()
185			});
186
187			await client.logger.logSoftBan(banOptions, msg.guild!, user, punishment);
188
189			await reply!.edit({
190			embeds: [
191			new MessageEmbed({
192			author: {
193			name: user.tag,
194			iconURL: user.displayAvatarURL()
195			},
196			description: `${await fetchEmojiStr('check')} Softbanned user ${user.tag}`,
197			fields: [
198			{
199			name: 'Softbanned by',
200			value: (<User> msg.member?.user).tag
201			},
202			{
203			name: 'Reason',
204			value: banOptions.reason ?? 'No reason provided'
205			}
206			]
207			})
208			]
209			});
210			}
211			catch (e) {
212			await reply!.edit({
213			embeds: [
214			new MessageEmbed()
215			.setColor('#f14a60')
216			.setDescription("Failed to softban this user. Maybe missing permisions or I'm not allowed to ban this user?")
217			]
218			});
219
220			return;
221			}
222			}
223			}