commands/settings/BlockedTokenCommand.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, Message, Permissions, Util } from "discord.js";
import DiscordClient from "../../client/Client";
import CommandOptions from "../../types/CommandOptions";
import InteractionOptions from "../../types/InteractionOptions";
import { emoji } from "../../utils/Emoji";
import BaseCommand from "../../utils/structures/BaseCommand";
import Pagination from "../../utils/Pagination";
import MessageEmbed from "../../client/MessageEmbed";

export default class BlockedTokenCommand extends BaseCommand {
    permissions = [Permissions.FLAGS.MANAGE_GUILD];
    name = "blockedtoken";
    group = "settings";
    aliases = ["btoken", "blockedtokens", "bannedtoken", "bannedtoken"];
    supportsInteractions = true;

    async run(client: DiscordClient, message: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        const subcommand = options.isInteraction ? options.options.getSubcommand(true) : options.argv[1];

        const subcommands = ["add", "remove", "has", "list"];

        if (!subcommand) {
            await message.reply(`${emoji('error')} You must provide a subcommand with this command. The valid subcommands are: \`${subcommands.join('`, `')}\`.`);
            return;
        }

        if (!subcommands.includes(subcommand)) {
            await this.deferReply(message, `${emoji('error')} Invalid subcommand provided. The valid subcommands are: \`${subcommands.join('`, `')}\`.`);
            return;
        }

        if (!options.isInteraction && options.argv[2] === undefined && subcommand !== 'list') {
            await message.reply(`${emoji('error')} You must specify a token ${subcommand === 'add' ? 'to block' : (subcommand === 'remove' ? 'to remove' : 'to check')}!`);
            return;
        }

        if (message instanceof CommandInteraction) {
            await message.deferReply();
        }

        switch (subcommand) {
            case 'add':
                const tokenToBlock = message instanceof Message ? message.content.slice(client.config.get('prefix').length).trim().slice((options as CommandOptions).argv[0].length).trim().slice(subcommand.length).trim() : message.options.getString('token', true);

                if (client.config.props[message.guildId!]?.filters.tokens.includes(tokenToBlock)) {
                    await this.deferReply(message, `${emoji('error')} The given token is already blocked.`);
                    return;
                }

                client.config.props[message.guildId!]?.filters.tokens.push(tokenToBlock);
                client.config.write();

                await this.deferReply(message, `${emoji('check')} The given token has been blocked.`);
            break;

            case 'has':
                const token = !options.isInteraction ? options.argv[2] : options.options.getString('token', true);

                if (client.config.props[message.guildId!]?.filters.tokens.includes(token)) {
                    await this.deferReply(message, `${emoji('check')} This token is in the blocklist.`);
                    return;
                }
                else {
                    await this.deferReply(message, `${emoji('error')} This token is not in the blocklist.`);
                    return;
                }
            break;

            case 'remove':
                const tokenToUnblock = message instanceof Message ? message.content.slice(client.config.get('prefix').length).trim().slice((options as CommandOptions).argv[0].length).trim().slice(subcommand.length).trim() : message.options.getString('token', true);

                const index = client.config.props[message.guildId!]?.filters.tokens.indexOf(tokenToUnblock);

                if (index === -1) {
                    await this.deferReply(message, `${emoji('error')} The given token was not blocked.`);
                    return;
                }

                client.config.props[message.guildId!]?.filters.tokens.splice(index, 1);
                
                client.config.write();
                await this.deferReply(message, `${emoji('check')} The given token has been unblocked.`);
            break;

            case 'list':
                const tokens: string[] = client.config.props[message.guildId!]?.filters.tokens ?? [];
                const safeTokens: string[][] = [];
                let length = 0;

                for (const unsafeToken of tokens) {
                    if (safeTokens.length === 0)
                        safeTokens.push([]);

                    const token = Util.escapeMarkdown(unsafeToken);

                    if ((length + token.length) >= 3000) {
                        safeTokens.push([token]);
                        length = token.length;
                        continue;
                    }

                    const index = safeTokens.length - 1;
                    
                    safeTokens[index].push(token);
                    length += token.length;
                }
                
                const pagination = new Pagination(safeTokens, {
                    channel_id: message.channelId!,
                    guild_id: message.guildId!,
                    limit: 1,
                    timeout: 120_000,
                    user_id: message.member!.user.id,
                    embedBuilder({ currentPage, data, maxPages }) {
                        return new MessageEmbed({
                            author: {
                                name: `Blocked tokens in ${message.guild!.name}`,
                                iconURL: message.guild!.iconURL() ?? undefined
                            },
                            description: '`' + data[0].join('`, `') + '`',
                            footer: {
                                text: `Page ${currentPage} of ${maxPages}`
                            }
                        });
                    },
                });

                let reply = await this.deferReply(message, await pagination.getMessageOptions());

                if (message instanceof CommandInteraction)
                    reply = (await message.fetchReply()) as Message;

                pagination.start(reply);
            break;
        }
    }
}
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, Message, Permissions, Util } from "discord.js";
21			import DiscordClient from "../../client/Client";
22			import CommandOptions from "../../types/CommandOptions";
23			import InteractionOptions from "../../types/InteractionOptions";
24			import { emoji } from "../../utils/Emoji";
25			import BaseCommand from "../../utils/structures/BaseCommand";
26			import Pagination from "../../utils/Pagination";
27			import MessageEmbed from "../../client/MessageEmbed";
28
29			export default class BlockedTokenCommand extends BaseCommand {
30			permissions = [Permissions.FLAGS.MANAGE_GUILD];
31			name = "blockedtoken";
32			group = "settings";
33			aliases = ["btoken", "blockedtokens", "bannedtoken", "bannedtoken"];
34			supportsInteractions = true;
35
36			async run(client: DiscordClient, message: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
37			const subcommand = options.isInteraction ? options.options.getSubcommand(true) : options.argv[1];
38
39			const subcommands = ["add", "remove", "has", "list"];
40
41			if (!subcommand) {
42			await message.reply(`${emoji('error')} You must provide a subcommand with this command. The valid subcommands are: \`${subcommands.join('`, `')}\`.`);
43			return;
44			}
45
46			if (!subcommands.includes(subcommand)) {
47			await this.deferReply(message, `${emoji('error')} Invalid subcommand provided. The valid subcommands are: \`${subcommands.join('`, `')}\`.`);
48			return;
49			}
50
51			if (!options.isInteraction && options.argv[2] === undefined && subcommand !== 'list') {
52			await message.reply(`${emoji('error')} You must specify a token ${subcommand === 'add' ? 'to block' : (subcommand === 'remove' ? 'to remove' : 'to check')}!`);
53			return;
54			}
55
56			if (message instanceof CommandInteraction) {
57			await message.deferReply();
58			}
59
60			switch (subcommand) {
61			case 'add':
62			const tokenToBlock = message instanceof Message ? message.content.slice(client.config.get('prefix').length).trim().slice((options as CommandOptions).argv[0].length).trim().slice(subcommand.length).trim() : message.options.getString('token', true);
63
64			if (client.config.props[message.guildId!]?.filters.tokens.includes(tokenToBlock)) {
65			await this.deferReply(message, `${emoji('error')} The given token is already blocked.`);
66			return;
67			}
68
69			client.config.props[message.guildId!]?.filters.tokens.push(tokenToBlock);
70			client.config.write();
71
72			await this.deferReply(message, `${emoji('check')} The given token has been blocked.`);
73			break;
74
75			case 'has':
76			const token = !options.isInteraction ? options.argv[2] : options.options.getString('token', true);
77
78			if (client.config.props[message.guildId!]?.filters.tokens.includes(token)) {
79			await this.deferReply(message, `${emoji('check')} This token is in the blocklist.`);
80			return;
81			}
82			else {
83			await this.deferReply(message, `${emoji('error')} This token is not in the blocklist.`);
84			return;
85			}
86			break;
87
88			case 'remove':
89			const tokenToUnblock = message instanceof Message ? message.content.slice(client.config.get('prefix').length).trim().slice((options as CommandOptions).argv[0].length).trim().slice(subcommand.length).trim() : message.options.getString('token', true);
90
91			const index = client.config.props[message.guildId!]?.filters.tokens.indexOf(tokenToUnblock);
92
93			if (index === -1) {
94			await this.deferReply(message, `${emoji('error')} The given token was not blocked.`);
95			return;
96			}
97
98			client.config.props[message.guildId!]?.filters.tokens.splice(index, 1);
99
100			client.config.write();
101			await this.deferReply(message, `${emoji('check')} The given token has been unblocked.`);
102			break;
103
104			case 'list':
105			const tokens: string[] = client.config.props[message.guildId!]?.filters.tokens ?? [];
106			const safeTokens: string[][] = [];
107			let length = 0;
108
109			for (const unsafeToken of tokens) {
110			if (safeTokens.length === 0)
111			safeTokens.push([]);
112
113			const token = Util.escapeMarkdown(unsafeToken);
114
115			if ((length + token.length) >= 3000) {
116			safeTokens.push([token]);
117			length = token.length;
118			continue;
119			}
120
121			const index = safeTokens.length - 1;
122
123			safeTokens[index].push(token);
124			length += token.length;
125			}
126
127			const pagination = new Pagination(safeTokens, {
128			channel_id: message.channelId!,
129			guild_id: message.guildId!,
130			limit: 1,
131			timeout: 120_000,
132			user_id: message.member!.user.id,
133			embedBuilder({ currentPage, data, maxPages }) {
134			return new MessageEmbed({
135			author: {
136			name: `Blocked tokens in ${message.guild!.name}`,
137			iconURL: message.guild!.iconURL() ?? undefined
138			},
139			description: '`' + data[0].join('`, `') + '`',
140			footer: {
141			text: `Page ${currentPage} of ${maxPages}`
142			}
143			});
144			},
145			});
146
147			let reply = await this.deferReply(message, await pagination.getMessageOptions());
148
149			if (message instanceof CommandInteraction)
150			reply = (await message.fetchReply()) as Message;
151
152			pagination.start(reply);
153			break;
154			}
155			}
156			}