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) {
        type RecordType = NonNullable<(typeof this.client.configManager.config)[string]>["message_filter"];

        this.client.configManager.config[guildId!]!.message_filter ??= {
            enabled: true,
            delete_message: true,
            send_logs: true
        } as RecordType;

        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.length === 0 ? "*No blocked message.*" : "`" + data[0].join("`, `") + "`",
                                footer: {
                                    text: `Page ${currentPage} of ${maxPages}`
                                }
                            });
                        }
                    });

                    const reply = await this.deferredReply(message, await pagination.getMessageOptions());
                    await pagination.start(reply);
                }

                break;
        }
    }
}
1	rakinar2	577	/**
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			type RecordType = NonNullable<(typeof this.client.configManager.config)[string]>["message_filter"];
81
82			this.client.configManager.config[guildId!]!.message_filter ??= {
83			enabled: true,
84			delete_message: true,
85			send_logs: true
86			} as RecordType;
87
88			this.client.configManager.config[guildId!]!.message_filter!.data ??= {
89			blocked_tokens: [],
90			blocked_words: [],
91			blocked_messages: []
92			};
93
94			this.client.configManager.config[guildId!]!.message_filter!.data!.blocked_messages ??= [];
95			}
96
97			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
98			const subcommand = (
99			context.isLegacy ? context.parsedNamedArgs.subcommand : context.options.getSubcommand(true)
100			)?.toString();
101
102			if (!this.subcommandsCustom.includes(subcommand)) {
103			await this.error(
104			message,
105			`Invalid subcommand provided. The valid subcommands are: \`${this.subcommandsCustom.join("`, `")}\`.`
106			);
107			return;
108			}
109
110			if (context.isLegacy && context.args[1] === undefined && subcommand !== "list") {
111			await this.error(
112			message,
113			`You must specify a message ${
114			subcommand === "add" ? "to block" : subcommand === "remove" ? "to remove" : "to check"
115			}!`
116			);
117			return;
118			}
119
120			if (!this.client.configManager.config[message.guildId!]) {
121			return;
122			}
123
124			await this.deferIfInteraction(message);
125
126			if (context.isLegacy) {
127			context.args.shift();
128			}
129
130			this.createConfigIfNotExists(message.guildId!);
131
132			switch (subcommand) {
133			case "add":
134			{
135			const messageToBlock = context.isLegacy ? context.args[0] : context.options.getString("message", true);
136
137			if (
138			!this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.includes(
139			messageToBlock
140			)
141			) {
142			this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.push(
143			messageToBlock
144			);
145			}
146
147			await this.client.configManager.write();
148			await this.success(message, "The given message has been blocked.");
149			}
150			break;
151
152			case "has":
153			{
154			const messageToCheck = context.isLegacy ? context.args[0] : context.options.getString("message", true);
155
156			if (
157			this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.includes(
158			messageToCheck
159			)
160			) {
161			await this.success(message, "This message is in the blocklist.");
162			} else {
163			await this.error(message, "This message is not in the blocklist.");
164			}
165			}
166
167			return;
168
169			case "remove":
170			{
171			const messageToRemove = context.isLegacy ? context.args[0] : context.options.getString("message", true);
172
173			const index =
174			this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.indexOf(
175			messageToRemove
176			);
177
178			if (!index \|\| index === -1) {
179			return;
180			}
181
182			this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages.splice(index, 1);
183
184			await this.client.configManager.write();
185			await this.success(message, "The given message has been unblocked.");
186			}
187			break;
188
189			case "list":
190			{
191			const messages: string[] =
192			this.client.configManager.config[message.guildId!]?.message_filter?.data?.blocked_messages ?? [];
193			const safeMessages: string[][] = [];
194			let length = 0;
195
196			for (const unsafeMessage of messages) {
197			if (safeMessages.length === 0) safeMessages.push([]);
198
199			const theMessage = escapeMarkdown(unsafeMessage);
200
201			if (length + theMessage.length >= 3000) {
202			safeMessages.push([theMessage]);
203			length = theMessage.length;
204			continue;
205			}
206
207			const index = safeMessages.length - 1;
208
209			safeMessages[index].push(theMessage);
210			length += theMessage.length;
211			}
212
213			const pagination = new Pagination(safeMessages, {
214			channelId: message.channelId!,
215			guildId: message.guildId!,
216			limit: 1,
217			timeout: 120_000,
218			userId: message.member!.user.id,
219			client: this.client,
220			embedBuilder({ currentPage, data, maxPages }) {
221			return new EmbedBuilder({
222			author: {
223			name: `Blocked messages in ${message.guild!.name}`,
224			iconURL: message.guild!.iconURL() ?? undefined
225			},
226			color: 0x007bff,
227			description: data.length === 0 ? "No blocked message." : "`" + data[0].join("`, `") + "`",
228			footer: {
229			text: `Page ${currentPage} of ${maxPages}`
230			}
231			});
232			}
233			});
234
235			const reply = await this.deferredReply(message, await pagination.getMessageOptions());
236			await pagination.start(reply);
237			}
238
239			break;
240			}
241			}
242			}