src/automod/MessageRuleService.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 {
    Message,
    PermissionFlagsBits,
    Snowflake,
    TextChannel,
    escapeCodeBlock,
    escapeInlineCode,
    escapeMarkdown
} from "discord.js";
import Service from "../core/Service";
import { CreateLogEmbedOptions } from "../services/LoggerService";
import { HasEventListeners } from "../types/HasEventListeners";
import { MessageRuleType } from "../types/MessageRuleSchema";
import { log, logError, logWarn } from "../utils/logger";
import { escapeRegex } from "../utils/utils";

export const name = "messageRuleService";

const handlers: Record<MessageRuleType["type"], Extract<keyof MessageRuleService, `rule${string}`>> = {
    domain: "ruleDomain",
    blocked_file_extension: "ruleBlockedFileExtension",
    blocked_mime_type: "ruleBlockedMimeType",
    anti_invite: "ruleAntiInvite",
    regex_filter: "ruleRegexFilter",
    block_repeated_text: "ruleRepeatedText",
    block_mass_mention: "ruleBlockMassMention",
    regex_must_match: "ruleRegexMustMatch"
};

type MessageRuleAction = MessageRuleType["actions"][number];

export default class MessageRuleService extends Service implements HasEventListeners {
    private config(guildId: Snowflake) {
        return this.client.configManager.config[guildId]?.message_rules;
    }

    async onMessageCreate(message: Message<boolean>) {
        if (message.author.bot) {
            return false;
        }

        const config = this.config(message.guildId!);

        if (
            !config?.enabled ||
            config?.global_disabled_channels?.includes(message.channelId!) ||
            this.client.permissionManager.isImmuneToAutoMod(message.member!, PermissionFlagsBits.ManageGuild)
        ) {
            return false;
        }

        return this.processMessageRules(message, config.rules);
    }

    private async processMessageRules(message: Message, rules: Array<MessageRuleType>) {
        for (const rule of rules) {
            if (rule.actions.length === 0) {
                log("No action found in this rule! Considering it as disabled.");
                continue;
            }

            if (rule.actions.length === 1 && rule.actions.includes("delete") && !message.deletable) {
                log("Missing permissions to delete messages, but the rule actions include `delete`. Skipping.");
                continue;
            }

            if (rule.actions.includes("mute") && rule.actions.includes("warn")) {
                logWarn("You cannot include mute and warn together as message rule actions! Skipping.");
                continue;
            }

            if (rule.disabled_channels.includes(message.channelId!)) {
                logWarn("This rule is disabled in this channel.");
                continue;
            }

            if (rule.immune_users.includes(message.author.id)) {
                logWarn("This user is immune to this rule.");
                continue;
            }

            if (message.member?.roles.cache.hasAny(...rule.immune_roles)) {
                logWarn("This user is immune to this rule, due to having some whitelisted roles.");
                continue;
            }

            const handlerFunctionName = handlers[rule.type];

            if (!handlerFunctionName || !handlerFunctionName.startsWith("rule")) {
                continue;
            }

            const handler = this[handlerFunctionName] as (
                ...args: any[]
            ) => Promise<boolean | null | undefined | CreateLogEmbedOptions>;

            if (typeof handler !== "function") {
                continue;
            }

            try {
                const result = await handler.call(this, message, rule);

                if (result) {
                    try {
                        for (const action of rule.actions) {
                            log("Taking action: ", action);
                            await this.takeAction(message, rule, action);
                        }

                        await this.client.logger
                            .logMessageRuleAction({
                                message,
                                actions: rule.actions,
                                rule: rule.type,
                                embedOptions: typeof result === "object" ? result : undefined
                            })
                            .catch(logError);
                    } catch (e) {
                        logError(e);
                    }

                    return true;
                }
            } catch (e) {
                logError(e);
                continue;
            }
        }

        return false;
    }

    private getReason(rule: MessageRuleType, key: Extract<keyof MessageRuleType, `${string}_reason`>) {
        return rule[key] ?? rule.common_reason ?? "Your message violated the server rules. Please be careful next time.";
    }

    private async takeAction(message: Message, rule: MessageRuleType, action: MessageRuleAction) {
        switch (action) {
            case "delete":
                if (message.deletable) {
                    await message.delete().catch(logError);
                }

                break;

            case "verbal_warn":
                {
                    const content = this.getReason(rule, "verbal_warning_reason");

                    await message.reply({
                        content
                    });
                }

                break;

            case "warn":
                {
                    const reason = this.getReason(rule, "warning_reason");

                    await this.client.infractionManager.createMemberWarn(message.member!, {
                        guild: message.guild!,
                        moderator: this.client.user!,
                        notifyUser: true,
                        reason,
                        sendLog: true
                    });
                }

                break;

            case "mute":
                {
                    const reason = this.getReason(rule, "mute_reason");

                    await this.client.infractionManager.createMemberMute(message.member!, {
                        guild: message.guild!,
                        moderator: this.client.user!,
                        notifyUser: true,
                        reason,
                        sendLog: true,
                        autoRemoveQueue: true,
                        duration: rule.mute_duration === -1 ? 60_000 : rule.mute_duration
                    });
                }

                break;

            case "clear":
                {
                    await this.client.infractionManager.bulkDeleteMessages({
                        guild: message.guild!,
                        moderator: this.client.user!,
                        count: 50,
                        sendLog: true,
                        messageChannel: message.channel! as TextChannel,
                        user: message.member!.user,
                        reason: "Message rule triggered"
                    });
                }

                break;
        }
    }

    async ruleDomain(message: Message, rule: Extract<MessageRuleType, { type: "domain" }>) {
        if (message.content.trim() === "") {
            return null;
        }
    
        const { domains, mode, scan_links_only } = rule;
    
        const prefix = scan_links_only ? `(https?://)` : `(https?://)?`;
        let specificRegex = `${prefix}(`;
        const genericRegex = `${prefix}([a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})`;
    
        let index = 0;
        for (const domain of domains) {
            const escapedDomain = escapeRegex(domain).replace(/\\\*/g, "[A-Za-z0-9-]+");
            specificRegex += `${escapedDomain}`;
    
            if (index < domains.length - 1) {
                specificRegex += "|";
            }
    
            index++;
        }
    
        specificRegex += ")\\S*";
        log(specificRegex);
    
        const specificMatches = [...(new RegExp(specificRegex, "i").exec(message.content) ?? [])];
        log(specificMatches);
    
        const genericMatches = [...(new RegExp(genericRegex, "i").exec(message.content) ?? [])];
        log(genericMatches);
    
        if (specificMatches.length > 0) {
            const cleanedDomain = (specificMatches[2] ?? specificMatches[1] ?? specificMatches[0]).replace(/https?:\/\//, '');
            if (mode === "disallow") {
                return {
                    title: "Blocked domain(s) detected",
                    fields: [
                        {
                            name: "Domain",
                            value: `\`${escapeMarkdown(cleanedDomain)}\``
                        }
                    ]
                 } satisfies CreateLogEmbedOptions;
            } else if (mode === "allow") {
                return false;
            }
        } else if (genericMatches.length > 0 && mode === "allow" && !scan_links_only) {
            const cleanedDomain = (genericMatches[2] ?? genericMatches[1] ?? genericMatches[0]).replace(/https?:\/\//, '');
            return {
                title: "Blocked domain(s) detected",
                fields: [
                    {
                        name: "Domain",
                        value: `\`${escapeMarkdown(cleanedDomain)}\``
                    }
                ]
            } satisfies CreateLogEmbedOptions;
        }
    
        return false;
    }
            
    async ruleBlockedFileExtension(message: Message, rule: Extract<MessageRuleType, { type: "blocked_file_extension" }>) {
        for (const attachment of message.attachments.values()) {
            for (const extension of rule.data) {
                if (attachment.proxyURL.endsWith(`.${extension}`)) {
                    return {
                        title: "File(s) with blocked extensions found",
                        fields: [
                            {
                                name: "File",
                                value: `[${attachment.name}](${attachment.url}): \`.${escapeMarkdown(extension)}\``
                            }
                        ]
                    };
                }
            }
        }

        return null;
    }

    async ruleBlockedMimeType(message: Message, rule: Extract<MessageRuleType, { type: "blocked_mime_type" }>) {
        for (const attachment of message.attachments.values()) {
            if (rule.data.includes(attachment.contentType ?? "unknown")) {
                return {
                    title: "File(s) with blocked MIME-type found",
                    fields: [
                        {
                            name: "File",
                            value: `[${attachment.name}](${attachment.url}): \`${attachment.contentType}\``
                        }
                    ]
                };
            }
        }

        return null;
    }

    async ruleAntiInvite(message: Message, rule: Extract<MessageRuleType, { type: "anti_invite" }>) {
        if (message.content.trim() === "") {
            return null;
        }

        const allowedInviteCodes = rule.allowed_invite_codes;
        const regex = /(https?:\/\/)?discord.(gg|com\/invite)\/([A-Za-z0-9_]+)/gi;
        const matches = message.content.matchAll(regex);

        for (const match of matches) {
            if (match[3] && !allowedInviteCodes.includes(match[3])) {
                if (rule.allow_internal_invites && this.client.inviteTracker.invites.has(`${message.guildId!}_${match[3]}`)) {
                    continue;
                }

                return {
                    title: "Posted Invite(s)",
                    fields: [
                        {
                            name: "Invite URL",
                            value: `\`https://discord.gg/${match[3]}\``
                        }
                    ]
                };
            }
        }

        return null;
    }

    async ruleRegexMustMatch(message: Message, rule: Extract<MessageRuleType, { type: "regex_must_match" }>) {
        if (message.content.trim() === "") {
            return null;
        }

        const { patterns } = rule;

        for (const pattern of patterns) {
            const regex = new RegExp(
                typeof pattern === "string" ? pattern : pattern[0],
                typeof pattern === "string" ? "gi" : pattern[1]
            );

            if (regex.test(message.content)) {
                return null;
            }
        }

        return {
            title: "Message did not match with the specified regex patterns"
        };
    }

    async ruleRegexFilter(message: Message, rule: Extract<MessageRuleType, { type: "regex_filter" }>) {
        if (message.content.trim() === "") {
            return null;
        }

        const { patterns } = rule;

        for (const pattern of patterns) {
            const regex = new RegExp(
                typeof pattern === "string" ? pattern : pattern[0],
                typeof pattern === "string" ? "gi" : pattern[1]
            );

            if (regex.test(message.content)) {
                return {
                    title: "Message matched with a blocked regex pattern",
                    fields: [
                        {
                            name: "Pattern Info",
                            value: `Pattern: \`${escapeInlineCode(
                                escapeCodeBlock(typeof pattern === "string" ? pattern : pattern[0])
                            )}\`\nFlags: \`${escapeInlineCode(
                                escapeCodeBlock(typeof pattern === "string" ? "gi" : pattern[1])
                            )}\``
                        }
                    ]
                };
            }
        }

        return null;
    }

    async ruleRepeatedText(message: Message, rule: Extract<MessageRuleType, { type: "block_repeated_text" }>) {
        if (message.content.trim() === "") {
            return null;
        }

        if (new RegExp("(.+)\\1{" + rule.max_repeated_chars + ",}", "gm").test(message.content)) {
            return {
                title: "Repeated text detected",
                fields: [
                    {
                        name: "Description",
                        value: `Too many repetitive characters were found`
                    }
                ]
            };
        } else if (new RegExp("^(.+)(?: +\\1){" + rule.max_repeated_words + "}", "gm").test(message.content)) {
            return {
                title: "Repeated text detected",
                fields: [
                    {
                        name: "Description",
                        value: `Too many repetitive words were found`
                    }
                ]
            };
        }

        return null;
    }

    async ruleBlockMassMention(message: Message, rule: Extract<MessageRuleType, { type: "block_mass_mention" }>) {
        if (message.content.trim() === "") {
            return null;
        }

        let data = [...message.content.matchAll(new RegExp(`\<\@[0-9]+\>`, "gm"))];

        console.log("users", data);

        if (data.length >= rule.max_mentions || (rule.max_user_mentions > 0 && data.length >= rule.max_user_mentions)) {
            return {
                title: "Mass mentions detected",
                fields: [
                    {
                        name: "Description",
                        value: `Too many users were mentioned`
                    }
                ]
            };
        }

        data = [...message.content.matchAll(new RegExp(`\<\@\&[0-9]+\>`, "gm"))];

        if (data.length >= rule.max_mentions || (rule.max_role_mentions > 0 && data.length >= rule.max_role_mentions)) {
            return {
                title: "Repeated text detected",
                fields: [
                    {
                        name: "Description",
                        value: `Too many roles were mentioned`
                    }
                ]
            };
        }

        return null;
    }
}
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 {
21	Message,
22	PermissionFlagsBits,
23	Snowflake,
24	TextChannel,
25	escapeCodeBlock,
26	escapeInlineCode,
27	escapeMarkdown
28	} from "discord.js";
29	import Service from "../core/Service";
30	import { CreateLogEmbedOptions } from "../services/LoggerService";
31	import { HasEventListeners } from "../types/HasEventListeners";
32	import { MessageRuleType } from "../types/MessageRuleSchema";
33	import { log, logError, logWarn } from "../utils/logger";
34	import { escapeRegex } from "../utils/utils";
35
36	export const name = "messageRuleService";
37
38	const handlers: Record<MessageRuleType["type"], Extract<keyof MessageRuleService, `rule${string}`>> = {
39	domain: "ruleDomain",
40	blocked_file_extension: "ruleBlockedFileExtension",
41	blocked_mime_type: "ruleBlockedMimeType",
42	anti_invite: "ruleAntiInvite",
43	regex_filter: "ruleRegexFilter",
44	block_repeated_text: "ruleRepeatedText",
45	block_mass_mention: "ruleBlockMassMention",
46	regex_must_match: "ruleRegexMustMatch"
47	};
48
49	type MessageRuleAction = MessageRuleType["actions"][number];
50
51	export default class MessageRuleService extends Service implements HasEventListeners {
52	private config(guildId: Snowflake) {
53	return this.client.configManager.config[guildId]?.message_rules;
54	}
55
56	async onMessageCreate(message: Message<boolean>) {
57	if (message.author.bot) {
58	return false;
59	}
60
61	const config = this.config(message.guildId!);
62
63	if (
64	!config?.enabled \|\|
65	config?.global_disabled_channels?.includes(message.channelId!) \|\|
66	this.client.permissionManager.isImmuneToAutoMod(message.member!, PermissionFlagsBits.ManageGuild)
67	) {
68	return false;
69	}
70
71	return this.processMessageRules(message, config.rules);
72	}
73
74	private async processMessageRules(message: Message, rules: Array<MessageRuleType>) {
75	for (const rule of rules) {
76	if (rule.actions.length === 0) {
77	log("No action found in this rule! Considering it as disabled.");
78	continue;
79	}
80
81	if (rule.actions.length === 1 && rule.actions.includes("delete") && !message.deletable) {
82	log("Missing permissions to delete messages, but the rule actions include `delete`. Skipping.");
83	continue;
84	}
85
86	if (rule.actions.includes("mute") && rule.actions.includes("warn")) {
87	logWarn("You cannot include mute and warn together as message rule actions! Skipping.");
88	continue;
89	}
90
91	if (rule.disabled_channels.includes(message.channelId!)) {
92	logWarn("This rule is disabled in this channel.");
93	continue;
94	}
95
96	if (rule.immune_users.includes(message.author.id)) {
97	logWarn("This user is immune to this rule.");
98	continue;
99	}
100
101	if (message.member?.roles.cache.hasAny(...rule.immune_roles)) {
102	logWarn("This user is immune to this rule, due to having some whitelisted roles.");
103	continue;
104	}
105
106	const handlerFunctionName = handlers[rule.type];
107
108	if (!handlerFunctionName \|\| !handlerFunctionName.startsWith("rule")) {
109	continue;
110	}
111
112	const handler = this[handlerFunctionName] as (
113	...args: any[]
114	) => Promise<boolean \| null \| undefined \| CreateLogEmbedOptions>;
115
116	if (typeof handler !== "function") {
117	continue;
118	}
119
120	try {
121	const result = await handler.call(this, message, rule);
122
123	if (result) {
124	try {
125	for (const action of rule.actions) {
126	log("Taking action: ", action);
127	await this.takeAction(message, rule, action);
128	}
129
130	await this.client.logger
131	.logMessageRuleAction({
132	message,
133	actions: rule.actions,
134	rule: rule.type,
135	embedOptions: typeof result === "object" ? result : undefined
136	})
137	.catch(logError);
138	} catch (e) {
139	logError(e);
140	}
141
142	return true;
143	}
144	} catch (e) {
145	logError(e);
146	continue;
147	}
148	}
149
150	return false;
151	}
152
153	private getReason(rule: MessageRuleType, key: Extract<keyof MessageRuleType, `${string}_reason`>) {
154	return rule[key] ?? rule.common_reason ?? "Your message violated the server rules. Please be careful next time.";
155	}
156
157	private async takeAction(message: Message, rule: MessageRuleType, action: MessageRuleAction) {
158	switch (action) {
159	case "delete":
160	if (message.deletable) {
161	await message.delete().catch(logError);
162	}
163
164	break;
165
166	case "verbal_warn":
167	{
168	const content = this.getReason(rule, "verbal_warning_reason");
169
170	await message.reply({
171	content
172	});
173	}
174
175	break;
176
177	case "warn":
178	{
179	const reason = this.getReason(rule, "warning_reason");
180
181	await this.client.infractionManager.createMemberWarn(message.member!, {
182	guild: message.guild!,
183	moderator: this.client.user!,
184	notifyUser: true,
185	reason,
186	sendLog: true
187	});
188	}
189
190	break;
191
192	case "mute":
193	{
194	const reason = this.getReason(rule, "mute_reason");
195
196	await this.client.infractionManager.createMemberMute(message.member!, {
197	guild: message.guild!,
198	moderator: this.client.user!,
199	notifyUser: true,
200	reason,
201	sendLog: true,
202	autoRemoveQueue: true,
203	duration: rule.mute_duration === -1 ? 60_000 : rule.mute_duration
204	});
205	}
206
207	break;
208
209	case "clear":
210	{
211	await this.client.infractionManager.bulkDeleteMessages({
212	guild: message.guild!,
213	moderator: this.client.user!,
214	count: 50,
215	sendLog: true,
216	messageChannel: message.channel! as TextChannel,
217	user: message.member!.user,
218	reason: "Message rule triggered"
219	});
220	}
221
222	break;
223	}
224	}
225
226	async ruleDomain(message: Message, rule: Extract<MessageRuleType, { type: "domain" }>) {
227	if (message.content.trim() === "") {
228	return null;
229	}
230
231	const { domains, mode, scan_links_only } = rule;
232
233	const prefix = scan_links_only ? `(https?://)` : `(https?://)?`;
234	let specificRegex = `${prefix}(`;
235	const genericRegex = `${prefix}([a-zA-Z0-9.-]+\\.[a-zA-Z]{2,})`;
236
237	let index = 0;
238	for (const domain of domains) {
239	const escapedDomain = escapeRegex(domain).replace(/\\\*/g, "[A-Za-z0-9-]+");
240	specificRegex += `${escapedDomain}`;
241
242	if (index < domains.length - 1) {
243	specificRegex += "\|";
244	}
245
246	index++;
247	}
248
249	specificRegex += ")\\S*";
250	log(specificRegex);
251
252	const specificMatches = [...(new RegExp(specificRegex, "i").exec(message.content) ?? [])];
253	log(specificMatches);
254
255	const genericMatches = [...(new RegExp(genericRegex, "i").exec(message.content) ?? [])];
256	log(genericMatches);
257
258	if (specificMatches.length > 0) {
259	const cleanedDomain = (specificMatches[2] ?? specificMatches[1] ?? specificMatches[0]).replace(/https?:\/\//, '');
260	if (mode === "disallow") {
261	return {
262	title: "Blocked domain(s) detected",
263	fields: [
264	{
265	name: "Domain",
266	value: `\`${escapeMarkdown(cleanedDomain)}\``
267	}
268	]
269	} satisfies CreateLogEmbedOptions;
270	} else if (mode === "allow") {
271	return false;
272	}
273	} else if (genericMatches.length > 0 && mode === "allow" && !scan_links_only) {
274	const cleanedDomain = (genericMatches[2] ?? genericMatches[1] ?? genericMatches[0]).replace(/https?:\/\//, '');
275	return {
276	title: "Blocked domain(s) detected",
277	fields: [
278	{
279	name: "Domain",
280	value: `\`${escapeMarkdown(cleanedDomain)}\``
281	}
282	]
283	} satisfies CreateLogEmbedOptions;
284	}
285
286	return false;
287	}
288
289	async ruleBlockedFileExtension(message: Message, rule: Extract<MessageRuleType, { type: "blocked_file_extension" }>) {
290	for (const attachment of message.attachments.values()) {
291	for (const extension of rule.data) {
292	if (attachment.proxyURL.endsWith(`.${extension}`)) {
293	return {
294	title: "File(s) with blocked extensions found",
295	fields: [
296	{
297	name: "File",
298	value: `[${attachment.name}](${attachment.url}): \`.${escapeMarkdown(extension)}\``
299	}
300	]
301	};
302	}
303	}
304	}
305
306	return null;
307	}
308
309	async ruleBlockedMimeType(message: Message, rule: Extract<MessageRuleType, { type: "blocked_mime_type" }>) {
310	for (const attachment of message.attachments.values()) {
311	if (rule.data.includes(attachment.contentType ?? "unknown")) {
312	return {
313	title: "File(s) with blocked MIME-type found",
314	fields: [
315	{
316	name: "File",
317	value: `[${attachment.name}](${attachment.url}): \`${attachment.contentType}\``
318	}
319	]
320	};
321	}
322	}
323
324	return null;
325	}
326
327	async ruleAntiInvite(message: Message, rule: Extract<MessageRuleType, { type: "anti_invite" }>) {
328	if (message.content.trim() === "") {
329	return null;
330	}
331
332	const allowedInviteCodes = rule.allowed_invite_codes;
333	const regex = /(https?:\/\/)?discord.(gg\|com\/invite)\/([A-Za-z0-9_]+)/gi;
334	const matches = message.content.matchAll(regex);
335
336	for (const match of matches) {
337	if (match[3] && !allowedInviteCodes.includes(match[3])) {
338	if (rule.allow_internal_invites && this.client.inviteTracker.invites.has(`${message.guildId!}_${match[3]}`)) {
339	continue;
340	}
341
342	return {
343	title: "Posted Invite(s)",
344	fields: [
345	{
346	name: "Invite URL",
347	value: `\`https://discord.gg/${match[3]}\``
348	}
349	]
350	};
351	}
352	}
353
354	return null;
355	}
356
357	async ruleRegexMustMatch(message: Message, rule: Extract<MessageRuleType, { type: "regex_must_match" }>) {
358	if (message.content.trim() === "") {
359	return null;
360	}
361
362	const { patterns } = rule;
363
364	for (const pattern of patterns) {
365	const regex = new RegExp(
366	typeof pattern === "string" ? pattern : pattern[0],
367	typeof pattern === "string" ? "gi" : pattern[1]
368	);
369
370	if (regex.test(message.content)) {
371	return null;
372	}
373	}
374
375	return {
376	title: "Message did not match with the specified regex patterns"
377	};
378	}
379
380	async ruleRegexFilter(message: Message, rule: Extract<MessageRuleType, { type: "regex_filter" }>) {
381	if (message.content.trim() === "") {
382	return null;
383	}
384
385	const { patterns } = rule;
386
387	for (const pattern of patterns) {
388	const regex = new RegExp(
389	typeof pattern === "string" ? pattern : pattern[0],
390	typeof pattern === "string" ? "gi" : pattern[1]
391	);
392
393	if (regex.test(message.content)) {
394	return {
395	title: "Message matched with a blocked regex pattern",
396	fields: [
397	{
398	name: "Pattern Info",
399	value: `Pattern: \`${escapeInlineCode(
400	escapeCodeBlock(typeof pattern === "string" ? pattern : pattern[0])
401	)}\`\nFlags: \`${escapeInlineCode(
402	escapeCodeBlock(typeof pattern === "string" ? "gi" : pattern[1])
403	)}\``
404	}
405	]
406	};
407	}
408	}
409
410	return null;
411	}
412
413	async ruleRepeatedText(message: Message, rule: Extract<MessageRuleType, { type: "block_repeated_text" }>) {
414	if (message.content.trim() === "") {
415	return null;
416	}
417
418	if (new RegExp("(.+)\\1{" + rule.max_repeated_chars + ",}", "gm").test(message.content)) {
419	return {
420	title: "Repeated text detected",
421	fields: [
422	{
423	name: "Description",
424	value: `Too many repetitive characters were found`
425	}
426	]
427	};
428	} else if (new RegExp("^(.+)(?: +\\1){" + rule.max_repeated_words + "}", "gm").test(message.content)) {
429	return {
430	title: "Repeated text detected",
431	fields: [
432	{
433	name: "Description",
434	value: `Too many repetitive words were found`
435	}
436	]
437	};
438	}
439
440	return null;
441	}
442
443	async ruleBlockMassMention(message: Message, rule: Extract<MessageRuleType, { type: "block_mass_mention" }>) {
444	if (message.content.trim() === "") {
445	return null;
446	}
447
448	let data = [...message.content.matchAll(new RegExp(`\<\@[0-9]+\>`, "gm"))];
449
450	console.log("users", data);
451
452	if (data.length >= rule.max_mentions \|\| (rule.max_user_mentions > 0 && data.length >= rule.max_user_mentions)) {
453	return {
454	title: "Mass mentions detected",
455	fields: [
456	{
457	name: "Description",
458	value: `Too many users were mentioned`
459	}
460	]
461	};
462	}
463
464	data = [...message.content.matchAll(new RegExp(`\<\@\&[0-9]+\>`, "gm"))];
465
466	if (data.length >= rule.max_mentions \|\| (rule.max_role_mentions > 0 && data.length >= rule.max_role_mentions)) {
467	return {
468	title: "Repeated text detected",
469	fields: [
470	{
471	name: "Description",
472	value: `Too many roles were mentioned`
473	}
474	]
475	};
476	}
477
478	return null;
479	}
480	}