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 } 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 { fetchEmoji } from '../../utils/Emoji';
import { hasPermission, shouldNotModerate } from '../../utils/util';

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

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

    async run(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && options.args[0] === undefined) {
            await msg.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 = msg.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 msg.reply({
                        content: 'Invalid channel given.'
                    });
                    
                    return;
                }
            }

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

                if (!user) {
                    throw new Error();
                }
            }
            catch (e) {
                console.log(e);
                
                await msg.reply({
                    embeds: [
                        new MessageEmbed()
                        .setColor('#f14a60')
                        .setDescription('Invalid user given.')
                    ]
                });
    
                return;
            }
        }
        
        if (msgCount === 0 && !user) {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription('You have to specify either the message count or the user.')
                ]
            });

            return;
        }

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

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

                if (member && shouldNotModerate(client, member)) {
                    await msg.reply({
                        embeds: [
                            { description: "Cannot clear messages from this user: Operation not permitted" }
                        ]
                    });
                    
                    return;
                }
            }
            catch (e) {
                console.log(e);
            }
        }

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

        let message = await msg.reply({
            embeds: [
                new MessageEmbed()
                .setColor('GOLD')
                .setDescription((await fetchEmoji('loading'))?.toString() + ' Deleting messages...')
            ]
        });

        if (msg instanceof CommandInteraction)
            message = <Message> await msg.fetchReply();

        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;

                /*for await (const [id, m] of fetched.entries()) {
                    try {
                        await m.delete();
                        count++;
                    }
                    catch (e) {
                        console.log('Error deleting message', e);
                    }
                }
                */
                
                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 [id, 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);
        }

        const messageOptions = {
            embeds: [
                new MessageEmbed()
                .setColor('GREEN')
                .setDescription((await fetchEmoji('check') as Emoji).toString() + " Deleted " + count + " message(s)" + (user ? " from user " + user.tag : ''))
            ]
        };

        if (msg instanceof CommandInteraction) {
            await msg.editReply(messageOptions);
        }
        else {
            await message!.edit(messageOptions);
        }

        setTimeout(async () => {
            try {
                if (msg instanceof Message)
                    await msg.delete();
            }
            catch (e) {
                console.log(e);                
            }
            
            try {
                await message!.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 } 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 { fetchEmoji } from '../../utils/Emoji';
28			import { hasPermission, shouldNotModerate } from '../../utils/util';
29
30			export default class ClearCommand extends BaseCommand {
31			supportsInteractions: boolean = true;
32			permissions = [Permissions.FLAGS.MANAGE_MESSAGES];
33
34			constructor() {
35			super('clear', 'moderation', []);
36			}
37
38			async run(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
39			if (!options.isInteraction && options.args[0] === undefined) {
40			await msg.reply({
41			embeds: [
42			new MessageEmbed()
43			.setColor('#f14a60')
44			.setDescription('This command requires at least one argument.')
45			]
46			});
47
48			return;
49			}
50
51			let user: User \| undefined \| null;
52			let msgCount = 0, channel: GuildChannel = msg.channel! as GuildChannel;
53
54			if (options.isInteraction) {
55			if (options.options.getUser('user'))
56			user = <User> options.options.getUser('user');
57
58			console.log(user?.tag);
59
60			if (options.options.getChannel('channel')) {
61			channel = <GuildChannel> options.options.getChannel('channel');
62
63			if (channel.type !== 'GUILD_TEXT' && channel.type !== 'GUILD_NEWS' && channel.type !== 'GUILD_PUBLIC_THREAD' && channel.type !== 'GUILD_PRIVATE_THREAD') {
64			await msg.reply({
65			content: 'Invalid channel given.'
66			});
67
68			return;
69			}
70			}
71
72			if (options.options.getInteger('count')) {
73			msgCount = <number> options.options.getInteger('count');
74			}
75			}
76			else {
77			try {
78			user = await getUser(client, msg as Message, options);
79
80			if (!user) {
81			throw new Error();
82			}
83			}
84			catch (e) {
85			console.log(e);
86
87			await msg.reply({
88			embeds: [
89			new MessageEmbed()
90			.setColor('#f14a60')
91			.setDescription('Invalid user given.')
92			]
93			});
94
95			return;
96			}
97			}
98
99			if (msgCount === 0 && !user) {
100			await msg.reply({
101			embeds: [
102			new MessageEmbed()
103			.setColor('#f14a60')
104			.setDescription('You have to specify either the message count or the user.')
105			]
106			});
107
108			return;
109			}
110
111			if (user) {
112			try {
113			const member = await msg.guild?.members.fetch(user.id);
114
115			if (member && !(await hasPermission(client, member, msg, null, "You don't have permission to clear messages from this user.")))
116			return;
117
118			if (member && shouldNotModerate(client, member)) {
119			await msg.reply({
120			embeds: [
121			{ description: "Cannot clear messages from this user: Operation not permitted" }
122			]
123			});
124
125			return;
126			}
127			}
128			catch (e) {
129			console.log(e);
130			}
131			}
132
133			let count = 0;
134			(global as any).deletingMessages = true;
135
136			let message = await msg.reply({
137			embeds: [
138			new MessageEmbed()
139			.setColor('GOLD')
140			.setDescription((await fetchEmoji('loading'))?.toString() + ' Deleting messages...')
141			]
142			});
143
144			if (msg instanceof CommandInteraction)
145			message = <Message> await msg.fetchReply();
146
147			if (msgCount === 0 && user) {
148			console.log(user?.tag);
149
150			let fetched;
151
152			do {
153			fetched = await (channel as TextChannel).messages.fetch({ limit: 100 });
154			fetched = await fetched.filter(m => m.author.id === user!.id && m.id !== message!.id && (Date.now() - m.createdTimestamp) <= (2 * 7 * 24 * 60 * 60 * 1000));
155			await (channel as TextChannel).bulkDelete(fetched);
156			count += fetched.size;
157
158			/*for await (const [id, m] of fetched.entries()) {
159			try {
160			await m.delete();
161			count++;
162			}
163			catch (e) {
164			console.log('Error deleting message', e);
165			}
166			}
167			*/
168
169			await new Promise(r => setTimeout(r, 900));
170			}
171			while (fetched.size >= 2);
172			}
173			else {
174			let fetched = 0;
175			let safeLimit = 0, safeLimit2 = 0;
176
177			do {
178			if (count >= msgCount \|\| safeLimit >= 50) {
179			break;
180			}
181
182			try {
183			const data = await (channel as TextChannel).messages.fetch({ limit: 100 });
184
185			fetched = 0;
186
187			for await (const [id, m] of data.entries()) {
188			try {
189			if (count >= msgCount \|\| safeLimit2 > 200) {
190			break;
191			}
192
193			if (user && m.author?.id !== user?.id) {
194			continue;
195			}
196
197			if (message!.id === m.id \|\| (Date.now() - m.createdTimestamp) > (2 * 7 * 24 * 60 * 60 * 1000))
198			continue;
199
200			if (m.deletable) {
201			console.log('here', user?.tag);
202
203			await m.delete();
204
205			fetched++;
206			count++;
207			safeLimit2++;
208			}
209
210			if (count % 10 === 0) {
211			await new Promise(r => setTimeout(r, 1100));
212			}
213			}
214			catch(e) {
215			console.log(e);
216			safeLimit2 += 100;
217			}
218			}
219			}
220			catch(e) {
221			console.log(e);
222
223			break;
224			}
225
226			safeLimit++;
227			}
228			while (fetched >= 2);
229			}
230
231			const messageOptions = {
232			embeds: [
233			new MessageEmbed()
234			.setColor('GREEN')
235			.setDescription((await fetchEmoji('check') as Emoji).toString() + " Deleted " + count + " message(s)" + (user ? " from user " + user.tag : ''))
236			]
237			};
238
239			if (msg instanceof CommandInteraction) {
240			await msg.editReply(messageOptions);
241			}
242			else {
243			await message!.edit(messageOptions);
244			}
245
246			setTimeout(async () => {
247			try {
248			if (msg instanceof Message)
249			await msg.delete();
250			}
251			catch (e) {
252			console.log(e);
253			}
254
255			try {
256			await message!.delete();
257			}
258			catch (e) {
259			console.log(e);
260			}
261			}, 5500);
262
263			(global as any).deletingMessages = false;
264			}
265			}