commands/moderation/ClearCommand.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 { CommandInteraction, Emoji, GuildChannel, Message, TextChannel, User, Permissions, GuildMember, Collection } 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 { emoji, fetchEmoji } from '../../utils/Emoji';
import { hasPermission, shouldNotModerate } from '../../utils/util';

interface ClearMessagesOptions {
    count?: number;
    user_id?: string;
    bypass?: string[];
    output?: boolean;
    user?: User;
}

export async function clearMessages(channel: TextChannel, { count, user_id, bypass = [], output = true, user }: ClearMessagesOptions) {
    if (!count && !user_id) {
        throw new Error("Either count or user_id needs to be specified");
    }

    if (count && count > 100) {
        throw new Error("Count cannot be more than 100");
    }

    if (count && count < 2) {
        throw new Error("Count cannot be less than 2");
    }

    let messages, deletedCount = 0, tag: string | undefined = user?.tag ?? undefined;

    do {
        messages = await channel.messages.fetch({ limit: count ?? 100 });

        messages = messages.filter(m => {
            if (user_id && !tag && user_id === m.author.id) {
                tag = m.author.tag;
            }

            return (!!user_id ? m.author.id === user_id : true) && 
                !bypass.includes(m.id) && 
                (Date.now() - m.createdTimestamp) <= (!!user_id && count === undefined ? (1 * 60 * 60 * 1000) : (2 * 7 * 24 * 60 * 60 * 1000));
        });

        await channel.bulkDelete(messages);
        deletedCount += messages.size;

        if (count !== undefined) {
            break;
        }
    }
    while (count === undefined && messages.size >= 2);
    
    channel.send({
        embeds: [
            new MessageEmbed()
            .setColor('GREEN')
            .setDescription((fetchEmoji('check') as Emoji).toString() + " Deleted " + deletedCount + " message(s)" + (user_id ? " from user " + tag : ''))
        ]
    })
    .then(message => {
        setTimeout(() => message.delete().catch(console.error), 5500);
    })
    .catch(console.error);

    return deletedCount;
}

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

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

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

            return;
        }

        let user: User | undefined | null;
        let msgCount = 0, channel: GuildChannel = message.channel! as GuildChannel;

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

            console.log(user?.tag);            

            if (options.options.getChannel('channel')) {
                channel = <GuildChannel> options.options.getChannel('channel');

                if (channel.type !== 'GUILD_TEXT' && channel.type !== 'GUILD_NEWS' && channel.type !== 'GUILD_PUBLIC_THREAD' && channel.type !== 'GUILD_PRIVATE_THREAD') {
                    await message.reply({
                        content: 'Invalid channel given.'
                    });
                    
                    return;
                }
            }

            if (options.options.getInteger('count')) {
                msgCount = <number> options.options.getInteger('count');
            }
        }
        else {
            try {
                user = await getUser(client, message as Message, options);

                if (!user) {
                    throw new Error();
                }
            }
            catch (e) {
                console.log(e);
                
                await message.reply({
                    embeds: [
                        new MessageEmbed()
                        .setColor('#f14a60')
                        .setDescription('Invalid user given.')
                    ]
                });
    
                return;
            }

            console.log(options.args);

            if (options.args[1] && !isNaN(parseInt(options.args[1]))) {
                msgCount = parseInt(options.args[1]);
                console.log("Count", msgCount);
                msgCount = !msgCount ? 0 : msgCount;

                if (msgCount !== 0 && msgCount < 2) {
                    await message.reply({
                        embeds: [
                            new MessageEmbed()
                            .setColor('#f14a60')
                            .setDescription('Message count cannot be less than 2.')
                        ]
                    });
        
                    return; 
                }

                if (msgCount !== 0 && msgCount > 100) {
                    await message.reply({
                        embeds: [
                            new MessageEmbed()
                            .setColor('#f14a60')
                            .setDescription('Message count cannot be more than 100.')
                        ]
                    });
        
                    return; 
                }
            }
        }
        
        if (msgCount === 0 && !user) {
            await message.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription('You have to specify either the message count or the user.')
                ]
            });

            return;
        }

        let member: GuildMember | undefined, hasMutedRole = false;

        if (user) {
            try {
                const _member = await message.guild?.members.fetch(user.id);

                if (_member && !(await hasPermission(client, _member, message, null, "You don't have permission to clear messages from this user.")))
                    return;

                if (_member && shouldNotModerate(client, _member)) {
                    await message.reply({
                        embeds: [
                            { description: "Cannot clear messages from this user: Operation not permitted" }
                        ]
                    });
                    
                    return;
                }

                member = _member;
                hasMutedRole = _member?.roles.cache.has(client.config.props[message.guild!.id].mute_role) ?? false;

                if (!hasMutedRole)
                    await _member?.roles.add(client.config.props[message.guild!.id].mute_role);
            }
            catch (e) {
                console.log(e);
            }
        }

        // let count = 0;
        (global as any).deletingMessages = true;

        if (message instanceof Message)
            await message.react(emoji('loading')!);
        else 
            await message.deferReply({ ephemeral: true });

        /**
         * if (msgCount === 0 && user) {
            console.log(user?.tag);
            
            let fetched;

            do {
                fetched = await (channel as TextChannel).messages.fetch({ limit: 100 });
                fetched = await fetched.filter(m => m.author.id === user!.id && m.id !== message!.id && (Date.now() - m.createdTimestamp) <= (2 * 7 * 24 * 60 * 60 * 1000));
                await (channel as TextChannel).bulkDelete(fetched);
                count += fetched.size;
                
                await new Promise(r => setTimeout(r, 900));
            }
            while (fetched.size >= 2);
        }
        else {
            let fetched = 0;
            let safeLimit = 0, safeLimit2 = 0;

            do {
                if (count >= msgCount || safeLimit >= 50) {
                    break;
                }

                try {
                    const data = await (channel as TextChannel).messages.fetch({ limit: 100 });

                    fetched = 0;

                    for await (const [, m] of data.entries()) {
                        try {
                            if (count >= msgCount || safeLimit2 > 200) {
                                break;
                            }

                            if (user && m.author?.id !== user?.id) {
                                continue;
                            }

                            if (message!.id === m.id || (Date.now() - m.createdTimestamp) > (2 * 7 * 24 * 60 * 60 * 1000))
                                continue;

                            if (m.deletable) {
                                console.log('here', user?.tag);
                                
                                await m.delete();

                                fetched++;
                                count++;
                                safeLimit2++;
                            }

                            if (count % 10 === 0) {
                                await new Promise(r => setTimeout(r, 1100));
                            }
                        }
                        catch(e) {
                            console.log(e);
                            safeLimit2 += 100;
                        }
                    }
                }
                catch(e) {
                    console.log(e);
                    
                    break;
                }

                safeLimit++;
            }
            while (fetched >= 2);
        }
         */

        try {
            await clearMessages(channel as TextChannel, {
                count: !msgCount || msgCount === 0 ? undefined : msgCount,
                user_id: user?.id ?? undefined,
                bypass: [message.id],
                output: false,
                user: user ?? undefined
            });
        }
        catch (e) {
            console.log(e);            
        }

        // const reply = await message.channel?.send({
        //     embeds: [
        //         new MessageEmbed()
        //         .setColor('GREEN')
        //         .setDescription((await fetchEmoji('check') as Emoji).toString() + " Deleted " + count + " message(s)" + (user ? " from user " + user.tag : ''))
        //     ]
        // });
        
        try {
            if (!hasMutedRole)
                await member?.roles.remove(client.config.props[message.guild!.id].mute_role);
        }
        catch (e) {
            console.error(e);
        }

        if (message instanceof CommandInteraction) {
            await message.editReply({ content: "Operation completed." });
        }

        if (message instanceof Message)
            await message.react(emoji('check')!);

        setTimeout(async () => {
            try {
                if (message instanceof Message)
                    await message.delete();
            }
            catch (e) {
                console.log(e);                
            }
            
            // try {
            //     await reply!.delete();
            // }
            // catch (e) {
            //     console.log(e);                
            // }
        }, 5500);

        (global as any).deletingMessages = false;
    }
}
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 { CommandInteraction, Emoji, GuildChannel, Message, TextChannel, User, Permissions, GuildMember, Collection } 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 { emoji, fetchEmoji } from '../../utils/Emoji';
28			import { hasPermission, shouldNotModerate } from '../../utils/util';
29
30			interface ClearMessagesOptions {
31			count?: number;
32			user_id?: string;
33			bypass?: string[];
34			output?: boolean;
35			user?: User;
36			}
37
38			export async function clearMessages(channel: TextChannel, { count, user_id, bypass = [], output = true, user }: ClearMessagesOptions) {
39			if (!count && !user_id) {
40			throw new Error("Either count or user_id needs to be specified");
41			}
42
43			if (count && count > 100) {
44			throw new Error("Count cannot be more than 100");
45			}
46
47			if (count && count < 2) {
48			throw new Error("Count cannot be less than 2");
49			}
50
51			let messages, deletedCount = 0, tag: string \| undefined = user?.tag ?? undefined;
52
53			do {
54			messages = await channel.messages.fetch({ limit: count ?? 100 });
55
56			messages = messages.filter(m => {
57			if (user_id && !tag && user_id === m.author.id) {
58			tag = m.author.tag;
59			}
60
61			return (!!user_id ? m.author.id === user_id : true) &&
62			!bypass.includes(m.id) &&
63			(Date.now() - m.createdTimestamp) <= (!!user_id && count === undefined ? (1 * 60 * 60 * 1000) : (2 * 7 * 24 * 60 * 60 * 1000));
64			});
65
66			await channel.bulkDelete(messages);
67			deletedCount += messages.size;
68
69			if (count !== undefined) {
70			break;
71			}
72			}
73			while (count === undefined && messages.size >= 2);
74
75			channel.send({
76			embeds: [
77			new MessageEmbed()
78			.setColor('GREEN')
79			.setDescription((fetchEmoji('check') as Emoji).toString() + " Deleted " + deletedCount + " message(s)" + (user_id ? " from user " + tag : ''))
80			]
81			})
82			.then(message => {
83			setTimeout(() => message.delete().catch(console.error), 5500);
84			})
85			.catch(console.error);
86
87			return deletedCount;
88			}
89
90			export default class ClearCommand extends BaseCommand {
91			supportsInteractions: boolean = true;
92			permissions = [Permissions.FLAGS.MANAGE_MESSAGES];
93
94			constructor() {
95			super('clear', 'moderation', []);
96			}
97
98			async run(client: DiscordClient, message: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
99			if (!options.isInteraction && options.args[0] === undefined) {
100			await message.reply({
101			embeds: [
102			new MessageEmbed()
103			.setColor('#f14a60')
104			.setDescription('This command requires at least one argument.')
105			]
106			});
107
108			return;
109			}
110
111			let user: User \| undefined \| null;
112			let msgCount = 0, channel: GuildChannel = message.channel! as GuildChannel;
113
114			if (options.isInteraction) {
115			if (options.options.getUser('user'))
116			user = <User> options.options.getUser('user');
117
118			console.log(user?.tag);
119
120			if (options.options.getChannel('channel')) {
121			channel = <GuildChannel> options.options.getChannel('channel');
122
123			if (channel.type !== 'GUILD_TEXT' && channel.type !== 'GUILD_NEWS' && channel.type !== 'GUILD_PUBLIC_THREAD' && channel.type !== 'GUILD_PRIVATE_THREAD') {
124			await message.reply({
125			content: 'Invalid channel given.'
126			});
127
128			return;
129			}
130			}
131
132			if (options.options.getInteger('count')) {
133			msgCount = <number> options.options.getInteger('count');
134			}
135			}
136			else {
137			try {
138			user = await getUser(client, message as Message, options);
139
140			if (!user) {
141			throw new Error();
142			}
143			}
144			catch (e) {
145			console.log(e);
146
147			await message.reply({
148			embeds: [
149			new MessageEmbed()
150			.setColor('#f14a60')
151			.setDescription('Invalid user given.')
152			]
153			});
154
155			return;
156			}
157
158			console.log(options.args);
159
160			if (options.args[1] && !isNaN(parseInt(options.args[1]))) {
161			msgCount = parseInt(options.args[1]);
162			console.log("Count", msgCount);
163			msgCount = !msgCount ? 0 : msgCount;
164
165			if (msgCount !== 0 && msgCount < 2) {
166			await message.reply({
167			embeds: [
168			new MessageEmbed()
169			.setColor('#f14a60')
170			.setDescription('Message count cannot be less than 2.')
171			]
172			});
173
174			return;
175			}
176
177			if (msgCount !== 0 && msgCount > 100) {
178			await message.reply({
179			embeds: [
180			new MessageEmbed()
181			.setColor('#f14a60')
182			.setDescription('Message count cannot be more than 100.')
183			]
184			});
185
186			return;
187			}
188			}
189			}
190
191			if (msgCount === 0 && !user) {
192			await message.reply({
193			embeds: [
194			new MessageEmbed()
195			.setColor('#f14a60')
196			.setDescription('You have to specify either the message count or the user.')
197			]
198			});
199
200			return;
201			}
202
203			let member: GuildMember \| undefined, hasMutedRole = false;
204
205			if (user) {
206			try {
207			const _member = await message.guild?.members.fetch(user.id);
208
209			if (_member && !(await hasPermission(client, _member, message, null, "You don't have permission to clear messages from this user.")))
210			return;
211
212			if (_member && shouldNotModerate(client, _member)) {
213			await message.reply({
214			embeds: [
215			{ description: "Cannot clear messages from this user: Operation not permitted" }
216			]
217			});
218
219			return;
220			}
221
222			member = _member;
223			hasMutedRole = _member?.roles.cache.has(client.config.props[message.guild!.id].mute_role) ?? false;
224
225			if (!hasMutedRole)
226			await _member?.roles.add(client.config.props[message.guild!.id].mute_role);
227			}
228			catch (e) {
229			console.log(e);
230			}
231			}
232
233			// let count = 0;
234			(global as any).deletingMessages = true;
235
236			if (message instanceof Message)
237			await message.react(emoji('loading')!);
238			else
239			await message.deferReply({ ephemeral: true });
240
241			/**
242			* if (msgCount === 0 && user) {
243			console.log(user?.tag);
244
245			let fetched;
246
247			do {
248			fetched = await (channel as TextChannel).messages.fetch({ limit: 100 });
249			fetched = await fetched.filter(m => m.author.id === user!.id && m.id !== message!.id && (Date.now() - m.createdTimestamp) <= (2 * 7 * 24 * 60 * 60 * 1000));
250			await (channel as TextChannel).bulkDelete(fetched);
251			count += fetched.size;
252
253			await new Promise(r => setTimeout(r, 900));
254			}
255			while (fetched.size >= 2);
256			}
257			else {
258			let fetched = 0;
259			let safeLimit = 0, safeLimit2 = 0;
260
261			do {
262			if (count >= msgCount \|\| safeLimit >= 50) {
263			break;
264			}
265
266			try {
267			const data = await (channel as TextChannel).messages.fetch({ limit: 100 });
268
269			fetched = 0;
270
271			for await (const [, m] of data.entries()) {
272			try {
273			if (count >= msgCount \|\| safeLimit2 > 200) {
274			break;
275			}
276
277			if (user && m.author?.id !== user?.id) {
278			continue;
279			}
280
281			if (message!.id === m.id \|\| (Date.now() - m.createdTimestamp) > (2 * 7 * 24 * 60 * 60 * 1000))
282			continue;
283
284			if (m.deletable) {
285			console.log('here', user?.tag);
286
287			await m.delete();
288
289			fetched++;
290			count++;
291			safeLimit2++;
292			}
293
294			if (count % 10 === 0) {
295			await new Promise(r => setTimeout(r, 1100));
296			}
297			}
298			catch(e) {
299			console.log(e);
300			safeLimit2 += 100;
301			}
302			}
303			}
304			catch(e) {
305			console.log(e);
306
307			break;
308			}
309
310			safeLimit++;
311			}
312			while (fetched >= 2);
313			}
314			*/
315
316			try {
317			await clearMessages(channel as TextChannel, {
318			count: !msgCount \|\| msgCount === 0 ? undefined : msgCount,
319			user_id: user?.id ?? undefined,
320			bypass: [message.id],
321			output: false,
322			user: user ?? undefined
323			});
324			}
325			catch (e) {
326			console.log(e);
327			}
328
329			// const reply = await message.channel?.send({
330			// embeds: [
331			// new MessageEmbed()
332			// .setColor('GREEN')
333			// .setDescription((await fetchEmoji('check') as Emoji).toString() + " Deleted " + count + " message(s)" + (user ? " from user " + user.tag : ''))
334			// ]
335			// });
336
337			try {
338			if (!hasMutedRole)
339			await member?.roles.remove(client.config.props[message.guild!.id].mute_role);
340			}
341			catch (e) {
342			console.error(e);
343			}
344
345			if (message instanceof CommandInteraction) {
346			await message.editReply({ content: "Operation completed." });
347			}
348
349			if (message instanceof Message)
350			await message.react(emoji('check')!);
351
352			setTimeout(async () => {
353			try {
354			if (message instanceof Message)
355			await message.delete();
356			}
357			catch (e) {
358			console.log(e);
359			}
360
361			// try {
362			// await reply!.delete();
363			// }
364			// catch (e) {
365			// console.log(e);
366			// }
367			}, 5500);
368
369			(global as any).deletingMessages = false;
370			}
371			}