commands/settings/BlockedMessageCommand.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * 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 { EmbedBuilder, PermissionFlagsBits, SlashCommandBuilder, Snowflake, escapeMarkdown } from "discord.js";
import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import Pagination from "../../utils/Pagination";

export default class BlockedMessageCommand extends Command {
    public readonly subcommandsCustom = ["add", "remove", "has", "list"];
    public readonly name = "blockedmessage";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.String],
            errors: {
                required: `Please provide a subcommand! The valid subcommands are: \`${this.subcommandsCustom.join("`, `")}\`.`,
                "type:invalid": `Please provide a __valid__ subcommand! The valid subcommands are: \`${this.subcommandsCustom.join(
                    "`, `"
                )}\`.`
            },
            name: "subcommand"
        }
    ];
    public readonly permissions = [PermissionFlagsBits.ManageGuild, PermissionFlagsBits.BanMembers];
    public readonly permissionMode = "or";

    public readonly description = "Manage blocked messages.";

    public readonly detailedDescription = [
        "Add/remove/check/view the blocked messages. All arguments, separated by spaces will be treated as different messages.\n",
        "**Subcommands**",
        "* `add <...messages>` - Add blocked message(s)",
        "* `remove <...messages>` - Remove blocked message(s)",
        "* `has <message>` - Check if the given message is blocked",
        "* `list` - List all the blocked messages"
    ].join("\n");

    public readonly argumentSyntaxes = ["<subcommand> [...args]"];

    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addSubcommand(subcommand =>
            subcommand
                .setName("add")
                .setDescription("Add a blocked message")
                .addStringOption(option => option.setName("message").setDescription("The message to block").setRequired(true))
        )
        .addSubcommand(subcommand =>
            subcommand
                .setName("remove")
                .setDescription("Remove blocked message")
                .addStringOption(option =>
                    option.setName("message").setDescription("The message to remove from blocklist").setRequired(true)
                )
        )
        .addSubcommand(subcommand =>
            subcommand
                .setName("has")
                .setDescription("Check if a blocked message exists in the blocklist")
                .addStringOption(option => option.setName("message").setDescription("The message to check").setRequired(true))
        )
        .addSubcommand(subcommand => subcommand.setName("list").setDescription("Show the blocked message list"));
    public readonly aliases = ["blockedmessages"];

    createConfigIfNotExists(guildId: Snowflake) {
        this.client.configManager.config[guildId!]!.message_filter ??= {
            enabled: true,
            delete_message: true,
            send_logs: true
        } as any;

        this.client.configManager.config[guildId!]!.message_filter!.data ??= {
            blocked_tokens: [],
            blocked_words: [],
            blocked_messages: []
        };

        this.client.configManager.config[guildId!]!.message_filter!.data!.blocked_messages ??= [];
    }

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        const subcommand = (
            context.isLegacy ? context.parsedNamedArgs.subcommand : context.options.getSubcommand(true)
        )?.toString();

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

        if (context.isLegacy && context.args[1] === undefined && subcommand !== "list") {
            await this.error(
                message,
                `You must specify a message ${
                    subcommand === "add" ? "to block" : subcommand === "remove" ? "to remove" : "to check"
                }!`
            );
            return;
        }

        if (!this.client.configManager.config[message.guildId!]) {
            return;
        }

        await this.deferIfInteraction(message);

        if (context.isLegacy) {
            context.args.shift();
        }

        this.createConfigIfNotExists(message.guildId!);

        switch (subcommand) {
            case "add":
                const messageToBlock = context.isLegacy ? context.args[0] : context.options.getString("message", true);

                if (
                    !this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.includes(
                        messageToBlock
                    )
                ) {
                    this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.push(
                        messageToBlock
                    );
                }

                await this.client.configManager.write();
                await this.success(message, `The given message has been blocked.`);
                break;

            case "has":
                const messageToCheck = context.isLegacy ? context.args[0] : context.options.getString("message", true);

                if (
                    this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.includes(
                        messageToCheck
                    )
                ) {
                    await this.success(message, `This message is in the blocklist.`);
                } else {
                    await this.error(message, `This message is not in the blocklist.`);
                }

                return;

            case "remove":
                const messageToRemove = context.isLegacy ? context.args[0] : context.options.getString("message", true);

                const index =
                    this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.indexOf(
                        messageToRemove
                    );

                if (!index || index === -1) {
                    return;
                }

                this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.splice(index, 1);

                await this.client.configManager.write();
                await this.success(message, `The given message has been unblocked.`);
                break;

            case "list":
                {
                    const messages: string[] =
                        this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages ?? [];
                    const safeMessages: string[][] = [];
                    let length = 0;

                    for (const unsafeMessage of messages) {
                        if (safeMessages.length === 0) safeMessages.push([]);

                        const theMessage = escapeMarkdown(unsafeMessage);

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

                        const index = safeMessages.length - 1;

                        safeMessages[index].push(theMessage);
                        length += theMessage.length;
                    }

                    const pagination = new Pagination(safeMessages, {
                        channelId: message.channelId!,
                        guildId: message.guildId!,
                        limit: 1,
                        timeout: 120_000,
                        userId: message.member!.user.id,
                        client: this.client,
                        embedBuilder({ currentPage, data, maxPages }) {
                            return new EmbedBuilder({
                                author: {
                                    name: `Blocked messages 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.deferredReply(message, await pagination.getMessageOptions());
                    await pagination.start(reply);
                }

                break;
        }
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
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 { EmbedBuilder, PermissionFlagsBits, SlashCommandBuilder, Snowflake, escapeMarkdown } from "discord.js";
21	import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
22	import Pagination from "../../utils/Pagination";
23
24	export default class BlockedMessageCommand extends Command {
25	public readonly subcommandsCustom = ["add", "remove", "has", "list"];
26	public readonly name = "blockedmessage";
27	public readonly validationRules: ValidationRule[] = [
28	{
29	types: [ArgumentType.String],
30	errors: {
31	required: `Please provide a subcommand! The valid subcommands are: \`${this.subcommandsCustom.join("`, `")}\`.`,
32	"type:invalid": `Please provide a __valid__ subcommand! The valid subcommands are: \`${this.subcommandsCustom.join(
33	"`, `"
34	)}\`.`
35	},
36	name: "subcommand"
37	}
38	];
39	public readonly permissions = [PermissionFlagsBits.ManageGuild, PermissionFlagsBits.BanMembers];
40	public readonly permissionMode = "or";
41
42	public readonly description = "Manage blocked messages.";
43
44	public readonly detailedDescription = [
45	"Add/remove/check/view the blocked messages. All arguments, separated by spaces will be treated as different messages.\n",
46	"Subcommands",
47	"* `add <...messages>` - Add blocked message(s)",
48	"* `remove <...messages>` - Remove blocked message(s)",
49	"* `has <message>` - Check if the given message is blocked",
50	"* `list` - List all the blocked messages"
51	].join("\n");
52
53	public readonly argumentSyntaxes = ["<subcommand> [...args]"];
54
55	public readonly slashCommandBuilder = new SlashCommandBuilder()
56	.addSubcommand(subcommand =>
57	subcommand
58	.setName("add")
59	.setDescription("Add a blocked message")
60	.addStringOption(option => option.setName("message").setDescription("The message to block").setRequired(true))
61	)
62	.addSubcommand(subcommand =>
63	subcommand
64	.setName("remove")
65	.setDescription("Remove blocked message")
66	.addStringOption(option =>
67	option.setName("message").setDescription("The message to remove from blocklist").setRequired(true)
68	)
69	)
70	.addSubcommand(subcommand =>
71	subcommand
72	.setName("has")
73	.setDescription("Check if a blocked message exists in the blocklist")
74	.addStringOption(option => option.setName("message").setDescription("The message to check").setRequired(true))
75	)
76	.addSubcommand(subcommand => subcommand.setName("list").setDescription("Show the blocked message list"));
77	public readonly aliases = ["blockedmessages"];
78
79	createConfigIfNotExists(guildId: Snowflake) {
80	this.client.configManager.config[guildId!]!.message_filter ??= {
81	enabled: true,
82	delete_message: true,
83	send_logs: true
84	} as any;
85
86	this.client.configManager.config[guildId!]!.message_filter!.data ??= {
87	blocked_tokens: [],
88	blocked_words: [],
89	blocked_messages: []
90	};
91
92	this.client.configManager.config[guildId!]!.message_filter!.data!.blocked_messages ??= [];
93	}
94
95	async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
96	const subcommand = (
97	context.isLegacy ? context.parsedNamedArgs.subcommand : context.options.getSubcommand(true)
98	)?.toString();
99
100	if (!this.subcommandsCustom.includes(subcommand)) {
101	await this.error(
102	message,
103	`Invalid subcommand provided. The valid subcommands are: \`${this.subcommandsCustom.join("`, `")}\`.`
104	);
105	return;
106	}
107
108	if (context.isLegacy && context.args[1] === undefined && subcommand !== "list") {
109	await this.error(
110	message,
111	`You must specify a message ${
112	subcommand === "add" ? "to block" : subcommand === "remove" ? "to remove" : "to check"
113	}!`
114	);
115	return;
116	}
117
118	if (!this.client.configManager.config[message.guildId!]) {
119	return;
120	}
121
122	await this.deferIfInteraction(message);
123
124	if (context.isLegacy) {
125	context.args.shift();
126	}
127
128	this.createConfigIfNotExists(message.guildId!);
129
130	switch (subcommand) {
131	case "add":
132	const messageToBlock = context.isLegacy ? context.args[0] : context.options.getString("message", true);
133
134	if (
135	!this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.includes(
136	messageToBlock
137	)
138	) {
139	this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.push(
140	messageToBlock
141	);
142	}
143
144	await this.client.configManager.write();
145	await this.success(message, `The given message has been blocked.`);
146	break;
147
148	case "has":
149	const messageToCheck = context.isLegacy ? context.args[0] : context.options.getString("message", true);
150
151	if (
152	this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.includes(
153	messageToCheck
154	)
155	) {
156	await this.success(message, `This message is in the blocklist.`);
157	} else {
158	await this.error(message, `This message is not in the blocklist.`);
159	}
160
161	return;
162
163	case "remove":
164	const messageToRemove = context.isLegacy ? context.args[0] : context.options.getString("message", true);
165
166	const index =
167	this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.indexOf(
168	messageToRemove
169	);
170
171	if (!index \|\| index === -1) {
172	return;
173	}
174
175	this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.splice(index, 1);
176
177	await this.client.configManager.write();
178	await this.success(message, `The given message has been unblocked.`);
179	break;
180
181	case "list":
182	{
183	const messages: string[] =
184	this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages ?? [];
185	const safeMessages: string[][] = [];
186	let length = 0;
187
188	for (const unsafeMessage of messages) {
189	if (safeMessages.length === 0) safeMessages.push([]);
190
191	const theMessage = escapeMarkdown(unsafeMessage);
192
193	if (length + theMessage.length >= 3000) {
194	safeMessages.push([theMessage]);
195	length = theMessage.length;
196	continue;
197	}
198
199	const index = safeMessages.length - 1;
200
201	safeMessages[index].push(theMessage);
202	length += theMessage.length;
203	}
204
205	const pagination = new Pagination(safeMessages, {
206	channelId: message.channelId!,
207	guildId: message.guildId!,
208	limit: 1,
209	timeout: 120_000,
210	userId: message.member!.user.id,
211	client: this.client,
212	embedBuilder({ currentPage, data, maxPages }) {
213	return new EmbedBuilder({
214	author: {
215	name: `Blocked messages in ${message.guild!.name}`,
216	iconURL: message.guild!.iconURL() ?? undefined
217	},
218	color: 0x007bff,
219	description: "`" + data[0].join("`, `") + "`",
220	footer: {
221	text: `Page ${currentPage} of ${maxPages}`
222	}
223	});
224	}
225	});
226
227	let reply = await this.deferredReply(message, await pagination.getMessageOptions());
228	await pagination.start(reply);
229	}
230
231	break;
232	}
233	}
234	}