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

// TODO: Add an allow/disallow mode to all roles

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, getEmoji } from "../utils/utils";

export const name = "messageRuleService";

type RuleHandlerMethod = Extract<keyof MessageRuleService, `rule${string}`>;

type RuleInfo =
    | RuleHandlerMethod
    | {
          method: RuleHandlerMethod;
          autoHandleModes?: boolean;
      };

const handlers: Record<MessageRuleType["type"], RuleInfo> = {
    domain: {
        method: "ruleDomain",
        autoHandleModes: false
    },
    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!) ||
            (await 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 handlerFunctionInfo = handlers[rule.type];
            const handlerFunctionName: RuleHandlerMethod | undefined =
                typeof handlerFunctionInfo === "string" ? handlerFunctionInfo : handlerFunctionInfo?.method;
            const handlerFunctionMetaInfo = (typeof handlerFunctionInfo === "string" ? null : handlerFunctionInfo) ?? {
                method: handlerFunctionName,
                autoHandleModes: true
            };

            if (!handlerFunctionInfo || !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);
                const inverse = rule.mode === "inverse";
                const { autoHandleModes } = handlerFunctionMetaInfo;

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

                        const embedOptions =
                            result && typeof result === "object" && !inverse
                                ? result
                                : inverse
                                ? {
                                      options: {
                                          description: `${getEmoji(this.client, "info")} This rule was __inversed__.`,
                                          ...(result && typeof result === "object" && "options" in result ? result.options : {})
                                      },
                                      ...(result && typeof result === "object" ? result : {})
                                  }
                                : undefined;

                        log(embedOptions);

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