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	/**
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	}