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	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 {
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			}