src/automod/MessageRules.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* 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, Util } from "discord.js";
import MessageEmbed from "../client/MessageEmbed";
import Service from "../utils/structures/Service";
import { hasConfig } from "../utils/util";

export enum MessageRuleType {
    RESTRICT_WORDS_IN_ROW = 'ruleRestrictWordsInRow',
    REGEX_STRICT = 'ruleRegexStrict',
}

export enum MessageRuleAction {
    NO_ACTION = 'no_action',
    WARN = 'warn',
    DELETE = 'delete'
}

export interface MessageRule {
    type: MessageRuleType;
    action: MessageRuleAction;
    meta: any;
    disabledChannels?: string[];
    enabledChannels?: string[];
}

export default class MessageRules extends Service {
    async onMessageCreate(message: Message) {
        if (!hasConfig(this.client, message.guildId!, "message_rules"))
            return;
        
        const { message_rules: { enabled, disabled_channels, rules }, mod_role } = this.client.config.props[message.guildId!];

        if (!enabled || disabled_channels.includes(message.channelId!) || message.member?.roles.cache.has(mod_role)) {
            return;
        }

        for await (const rule of (rules as MessageRule[])) {
            console.log(rule.type);

            if (rule.type.startsWith('rule') && typeof this[rule.type] === 'function') {
                if (rule.disabledChannels && rule.disabledChannels.includes(message.channel.id!)) {
                    continue;
                }

                if (rule.enabledChannels && !rule.enabledChannels.includes(message.channel.id!)) {
                    continue;
                }

                if (!(await this[rule.type](message, rule))) {
                    return false;
                }
            }
        }

        return true;
    }

    async ruleRegexStrict(message: Message, rule: MessageRule) {
        const { patterns } = rule.meta as { patterns: string[] };

        for (const pattern of patterns) {
            if (!(new RegExp(pattern, 'gi').test(message.content))) {
                message.delete().catch(console.error);
                this.client.logger.loggingChannel(message.guildId!)?.send({
                    embeds: [
                        new MessageEmbed({
                            author: {
                                name: message.author.tag,
                                iconURL: message.author.displayAvatarURL()
                            },
                            color: 0xf14a60,
                            title: 'Regex Rule Does Not Match',
                            description: message.content,
                            fields: [
                                {
                                    name: 'Pattern',
                                    value: `\`${Util.escapeMarkdown(pattern)}\``
                                },
                                {
                                    name: 'User ID',
                                    value: message.author.id
                                },
                                {
                                    name: 'Channel',
                                    value: `<#${message.channel.id}> (${message.channel.id})`
                                }
                            ],
                            footer: { text: 'Deleted' }
                        })
                        .setTimestamp()
                    ]
                }).catch(console.error);

                return false;
            }
        }

        return true;
    }

    async restrictWordsInRowHandler(message: Message, rule: MessageRule) {
        console.log("Test");

        if (rule.action === MessageRuleAction.DELETE) {
            await message.delete();
        }
        else if (rule.action === MessageRuleAction.WARN) {
            // TODO
        }
    }

    async ruleRestrictWordsInRow(message: Message, rule: MessageRule) {
        const words = message.content.toLowerCase().split(/\s+/);

        for await (const token of (rule.meta?.tokens ?? [])) {
            const tokenWords = token.toLowerCase().split(/\s+/);

            let wordsInTokensCopy = [...tokenWords];

            for (const word of words) {
                console.log(word, wordsInTokensCopy.indexOf(word));
                const index = wordsInTokensCopy.indexOf(word);

                if (index !== -1) {
                    wordsInTokensCopy.splice(index, 1);
                    console.log(wordsInTokensCopy);
                }
                else if (wordsInTokensCopy.length === 0) {
                    await this.restrictWordsInRowHandler(message, rule);
                    return false;
                }
                else if (wordsInTokensCopy.length !== tokenWords.length) {
                    wordsInTokensCopy = [...tokenWords];
                }
            }
            
            if (wordsInTokensCopy.length === 0)
                await this.restrictWordsInRowHandler(message, rule);
        }

        return true;
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2022 OSN Inc.
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 { Message, Util } from "discord.js";
21			import MessageEmbed from "../client/MessageEmbed";
22			import Service from "../utils/structures/Service";
23			import { hasConfig } from "../utils/util";
24
25			export enum MessageRuleType {
26			RESTRICT_WORDS_IN_ROW = 'ruleRestrictWordsInRow',
27			REGEX_STRICT = 'ruleRegexStrict',
28			}
29
30			export enum MessageRuleAction {
31			NO_ACTION = 'no_action',
32			WARN = 'warn',
33			DELETE = 'delete'
34			}
35
36			export interface MessageRule {
37			type: MessageRuleType;
38			action: MessageRuleAction;
39			meta: any;
40			disabledChannels?: string[];
41			enabledChannels?: string[];
42			}
43
44			export default class MessageRules extends Service {
45			async onMessageCreate(message: Message) {
46			if (!hasConfig(this.client, message.guildId!, "message_rules"))
47			return;
48
49			const { message_rules: { enabled, disabled_channels, rules }, mod_role } = this.client.config.props[message.guildId!];
50
51			if (!enabled \|\| disabled_channels.includes(message.channelId!) \|\| message.member?.roles.cache.has(mod_role)) {
52			return;
53			}
54
55			for await (const rule of (rules as MessageRule[])) {
56			console.log(rule.type);
57
58			if (rule.type.startsWith('rule') && typeof this[rule.type] === 'function') {
59			if (rule.disabledChannels && rule.disabledChannels.includes(message.channel.id!)) {
60			continue;
61			}
62
63			if (rule.enabledChannels && !rule.enabledChannels.includes(message.channel.id!)) {
64			continue;
65			}
66
67			if (!(await this[rule.type](message, rule))) {
68			return false;
69			}
70			}
71			}
72
73			return true;
74			}
75
76			async ruleRegexStrict(message: Message, rule: MessageRule) {
77			const { patterns } = rule.meta as { patterns: string[] };
78
79			for (const pattern of patterns) {
80			if (!(new RegExp(pattern, 'gi').test(message.content))) {
81			message.delete().catch(console.error);
82			this.client.logger.loggingChannel(message.guildId!)?.send({
83			embeds: [
84			new MessageEmbed({
85			author: {
86			name: message.author.tag,
87			iconURL: message.author.displayAvatarURL()
88			},
89			color: 0xf14a60,
90			title: 'Regex Rule Does Not Match',
91			description: message.content,
92			fields: [
93			{
94			name: 'Pattern',
95			value: `\`${Util.escapeMarkdown(pattern)}\``
96			},
97			{
98			name: 'User ID',
99			value: message.author.id
100			},
101			{
102			name: 'Channel',
103			value: `<#${message.channel.id}> (${message.channel.id})`
104			}
105			],
106			footer: { text: 'Deleted' }
107			})
108			.setTimestamp()
109			]
110			}).catch(console.error);
111
112			return false;
113			}
114			}
115
116			return true;
117			}
118
119			async restrictWordsInRowHandler(message: Message, rule: MessageRule) {
120			console.log("Test");
121
122			if (rule.action === MessageRuleAction.DELETE) {
123			await message.delete();
124			}
125			else if (rule.action === MessageRuleAction.WARN) {
126			// TODO
127			}
128			}
129
130			async ruleRestrictWordsInRow(message: Message, rule: MessageRule) {
131			const words = message.content.toLowerCase().split(/\s+/);
132
133			for await (const token of (rule.meta?.tokens ?? [])) {
134			const tokenWords = token.toLowerCase().split(/\s+/);
135
136			let wordsInTokensCopy = [...tokenWords];
137
138			for (const word of words) {
139			console.log(word, wordsInTokensCopy.indexOf(word));
140			const index = wordsInTokensCopy.indexOf(word);
141
142			if (index !== -1) {
143			wordsInTokensCopy.splice(index, 1);
144			console.log(wordsInTokensCopy);
145			}
146			else if (wordsInTokensCopy.length === 0) {
147			await this.restrictWordsInRowHandler(message, rule);
148			return false;
149			}
150			else if (wordsInTokensCopy.length !== tokenWords.length) {
151			wordsInTokensCopy = [...tokenWords];
152			}
153			}
154
155			if (wordsInTokensCopy.length === 0)
156			await this.restrictWordsInRowHandler(message, rule);
157			}
158
159			return true;
160			}
161			}