commands/settings/BlockedWordCommand.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, MessageEmbed, 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";

export default class BlockedWordCommand extends BaseCommand {
    permissions = [Permissions.FLAGS.MANAGE_GUILD];
    name = "blockedword";
    group = "settings";
    aliases = ["bword", "blockedwords", "bannedword", "bannedword"];
    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 word ${subcommand === 'add' ? 'to block' : (subcommand === 'remove' ? 'to remove' : 'to check')}!`);
            return;
        }

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

        switch (subcommand) {
            case 'add':
                if (!options.isInteraction) {
                    options.args.shift();
                }

                const words = !options.isInteraction ? options.args : options.options.getString('words', true).split(/ +/);

                for await (const word of words) {
                    if (client.config.props[message.guildId!]?.filters.words.includes(word)) {
                        continue;
                    }
    
                    client.config.props[message.guildId!]?.filters.words.push(word);
                }

                client.config.write();

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

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

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

            case 'remove':
                const wordsToRemove = !options.isInteraction ? options.args : options.options.getString('words', true).split(/ +/);

                for await (const word of wordsToRemove) {
                    const index = client.config.props[message.guildId!]?.filters.words.indexOf(word);

                    if (index === -1) {
                        continue;
                    }

                    client.config.props[message.guildId!]?.filters.words.splice(index, 1);
                }
                
                client.config.write();
                await this.deferReply(message, `${emoji('check')} The given word(s) have been unblocked.`);
            break;
            
            case 'list':
                {
                    const words: string[] = client.config.props[message.guildId!]?.filters.words ?? [];
                    const safeWords: string[][] = [];
                    let length = 0;

                    for (const unsafeWord of words) {
                        if (safeWords.length === 0)
                            safeWords.push([]);

                        const word = Util.escapeMarkdown(unsafeWord);

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

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