.gitignore

@@ -6,4 +6,5 @@ breadbot.db
 tools/profanity_filter/bin/Words.json
 tools/profanity_filter/src/Words.json
 bin/config.json
-bin/Words.json
+bin/Words.json
+bin/__pycache__

bin/breadbot_common.py

@@ -23,7 +23,7 @@ class Database():
             where = self.__generate_basic_where_clause(where) if not where is None else ""
         )
 
-        return self.query(query_string, [element["value"] for element in where] if not where is None else None, values)[1]
+        return self.query(query_string, values)[1]
 
     def insert(self, table: str, columns: list[str], values: list) -> int:
         query_string = "INSERT INTO {table} ({columns}) VALUES ({values})".format(

bin/profanity_regex_inserter.py

@@ -29,7 +29,7 @@ print(db.select("db_server", ["server_snowflake"]))
 
 for element in db.select("db_server", ["server_snowflake"]):
     for word in words_list:
-        regex_string = "(^|\\\\W|\\\\b)"
+        regex_string = "(^|\\W|\\b)"
 
         for i in range(len(word)):
             if word[i] in config_json["profanity"]["replacers"].keys():
@@ -37,7 +37,7 @@ for element in db.select("db_server", ["server_snowflake"]):
             else:
                 regex_string = regex_string + word[i] + "{1,}"
 
-        regex_string = regex_string + "($|\\\\W|\\\\b)"
+        regex_string = regex_string + "($|\\W|\\b)"
 
         db.insert("db_message_regex", ["regex", "word", "serverServerSnowflake"], [regex_string, word, element[0]])
 

src/breadbot.ts

@@ -66,6 +66,8 @@ client.once(Events.ClientReady, async () => {
     const messageRepo = dataSource.getRepository(DBMessage)
     const mccRepo = dataSource.getRepository(DBMessageContentChanges)
     const maRepo = dataSource.getRepository(DBMessageAttachments)
+    const regexesRepo = dataSource.getRepository(DBMessageRegex)
+    const matchesRepo = dataSource.getRepository(DBMessageRegexMatches)
 
     client.guilds.cache.forEach(async (guild: Guild) => {
         const server: DBServer | null = await insertGuild(serverRepo, guild)
@@ -113,7 +115,7 @@ client.once(Events.ClientReady, async () => {
     })
 
     setupRoleCapture(client, serverRepo, roleRepo)
-    setupMessageCapture(client, channelRepo, userRepo, messageRepo, mccRepo, maRepo)
+    setupMessageCapture(client, serverRepo, channelRepo, userRepo, messageRepo, mccRepo, maRepo, regexesRepo, matchesRepo)
 
     console.log("Breadbot is Ready")
 })

src/utilties/discord/messages.ts

@@ -100,8 +100,4 @@ export async function markMessageDeleted(db: Repository<DBMessage>, message: Omi
         console.log(err)
         return null
     }
-}
-
-export async function checkYourProfanity(messageDB: Repository<DBMessage>, regexDB: Repository<DBMessageRegex>, message: OmitPartialGroupDMChannel<Message<boolean>> | PartialMessage) : Promise<DBMessage | null> {
-    return null
 }

src/utilties/discord/regex_matching.ts

@@ -1,4 +1,4 @@
-import { Guild, Message, OmitPartialGroupDMChannel, PartialMessage } from "discord.js";
+import { Client, Guild, Message, OmitPartialGroupDMChannel, PartialMessage, TextChannel } from "discord.js";
 import { DBMessageRegex } from "../storage/entities/DBMessageRegex";
 import { Repository } from "typeorm";
 import { DBServer } from "../storage/entities/DBServer";
@@ -23,6 +23,7 @@ export async function checkMatchingRegexes(regexes: DBMessageRegex[], testString
     let matchedRegexes: DBMessageRegex[] = []
     
     regexes.forEach((regex) => {
+        console.log(regex.regex)
         const regexObj = new RegExp(regex.regex, 'gmi')
 
         if(regexObj.test(testString)) {
@@ -50,4 +51,30 @@ export async function insertAnyRegexMatches(regexes: DBMessageRegex[], db: Repos
     })
 
     await db.save(matches)
+}
+
+export async function checkYourProfanity(client: Client, serverDB: Repository<DBServer>, matchDB: Repository<DBMessageRegexMatches>, regexDB: Repository<DBMessageRegex>, message: OmitPartialGroupDMChannel<Message<boolean>> | PartialMessage) {
+    if(message.guild != null && message.content != null) {
+        const regexes : DBMessageRegex[] | null | undefined = await getRegexesForGuild(serverDB, message.guild)
+        console.log(regexes?.length)
+        console.log(message.content)
+        if(regexes != null && regexes != undefined && regexes.length != 0) {
+            const matchingRegexes : DBMessageRegex[] | null = await checkMatchingRegexes(regexes, message.content)
+
+            matchingRegexes?.forEach((regex) => {
+                console.log(`${regex.word}`)
+            })
+
+            if(matchingRegexes != null && matchingRegexes.length != 0) {
+                const channel: TextChannel | null = (await client.channels.fetch(message.channelId)) as TextChannel
+
+                if(channel) {
+                    await channel.send(`${message.author} watch your language! Your message has been deleted and this incident has been logged!`)
+                }
+
+                await insertAnyRegexMatches(matchingRegexes, matchDB, message)
+                await message.delete()
+            }
+        }
+    }
 }

src/utilties/events/messages.ts

@@ -13,17 +13,25 @@ import { config } from "../../config";
 import path from "path";
 import { Readable } from "stream"
 import { finished } from "stream/promises";
+import { checkYourProfanity } from "../discord/regex_matching";
+import { DBServer } from "../storage/entities/DBServer";
+import { DBMessageRegex } from "../storage/entities/DBMessageRegex";
+import { DBMessageRegexMatches } from "../storage/entities/DBMessageRegexMatches";
 
 export function setupMessageCapture(client: Client, 
+    serverDB: Repository<DBServer>,
     channelDB: Repository<DBChannel>,
     userDB: Repository<DBUser>,
     messageDB: Repository<DBMessage>, 
     mccDB: Repository<DBMessageContentChanges>,
-    maDB: Repository<DBMessageAttachments>
+    maDB: Repository<DBMessageAttachments>,
+    regexesDB: Repository<DBMessageRegex>,
+    matchesDB: Repository<DBMessageRegexMatches>
 ) {
     client.on(Events.MessageCreate, async (message) => {
         console.log("MESSAGE CREATE")
         await processMessageCreate(channelDB, userDB, messageDB, maDB, message)
+        await checkYourProfanity(client, serverDB, matchesDB, regexesDB, message)
     })
 
     client.on(Events.MessageUpdate, async (oldMessage, newMessage) => {
@@ -31,6 +39,7 @@ export function setupMessageCapture(client: Client,
         console.log(`Old Message ID: ${oldMessage.id}`)
         console.log(`New Message ID: ${newMessage.id}`)
         await processMessageModify(messageDB, mccDB, maDB, newMessage)
+        await checkYourProfanity(client, serverDB, matchesDB, regexesDB, newMessage)
     })
 
     client.on(Events.MessageDelete, async (deletedMessage) => {

src/utilties/storage/entities/DBMessage.ts

@@ -31,6 +31,6 @@ export class DBMessage {
     @OneToMany(() => DBMessageAttachments, (ma: DBMessageAttachments) => ma.attachment_snowflake, {nullable: true, cascade: true})
     attachments: DBMessageAttachments[] | null
 
-    @OneToOne(() => DBMessageRegexMatches, (mrm: DBMessageRegexMatches) => mrm.message, {nullable: true})
-    violation_regex: DBMessageRegexMatches | null
+    @OneToMany(() => DBMessageRegexMatches, (mrm: DBMessageRegexMatches) => mrm.message, {nullable: true})
+    violation_regex: DBMessageRegexMatches[] | null
 }

src/utilties/storage/entities/DBMessageRegexMatches.ts

@@ -1,4 +1,4 @@
-import { Entity, ManyToOne, OneToOne, PrimaryGeneratedColumn } from "typeorm";
+import { Entity, ManyToMany, ManyToOne, OneToOne, PrimaryGeneratedColumn } from "typeorm";
 import { DBMessage } from "./DBMessage";
 import { DBMessageRegex } from "./DBMessageRegex";
 
@@ -7,7 +7,7 @@ export class DBMessageRegexMatches {
     @PrimaryGeneratedColumn()
     message_regex_match_id: number
 
-    @OneToOne(() => DBMessage, (message: DBMessage) => message.violation_regex)
+    @ManyToMany(() => DBMessage, (message: DBMessage) => message.violation_regex)
     message: DBMessage
 
     @ManyToOne(() => DBMessageRegex, (regex: DBMessageRegex) => regex.matches)