Update filter, last time for now.

filter/filter.py

@@ -12,33 +12,29 @@ class FilterStorage:
     def _setup(self):
         self.cursor.execute("""
         CREATE TABLE IF NOT EXISTS filter_data (
-            guild_id INTEGER,
+            guild_id INTEGER NOT NULL,
-            key TEXT,
+            key TEXT NOT NULL,
-            value TEXT,
+            value TEXT NOT NULL,
-            PRIMARY KEY (guild_id, key)
+            PRIMARY KEY (guild_id, key, value)
         )
         """)
         self.conn.commit()
     
     def get(self, guild_id, key):
         self.cursor.execute("SELECT value FROM filter_data WHERE guild_id = ? AND key = ?", (guild_id, key))
-        result = self.cursor.fetchone()
+        result = self.cursor.fetchall()
-        return json.loads(result[0]) if result else []
+        return [json.loads(row[0]) for row in result] if result else []
     
     def add(self, guild_id, key, value):
-        data = self.get(guild_id, key)
+        if value not in self.get(guild_id, key):
-        if value not in data:
+            self.cursor.execute("INSERT INTO filter_data (guild_id, key, value) VALUES (?, ?, ?)", (guild_id, key, json.dumps(value)))
-            data.append(value)
-            self.cursor.execute("REPLACE INTO filter_data (guild_id, key, value) VALUES (?, ?, ?)", (guild_id, key, json.dumps(data)))
             self.conn.commit()
             return True
         return False
     
     def remove(self, guild_id, key, value):
-        data = self.get(guild_id, key)
+        if value in self.get(guild_id, key):
-        if value in data:
+            self.cursor.execute("DELETE FROM filter_data WHERE guild_id = ? AND key = ? AND value = ?", (guild_id, key, json.dumps(value)))
-            data.remove(value)
-            self.cursor.execute("REPLACE INTO filter_data (guild_id, key, value) VALUES (?, ?, ?)", (guild_id, key, json.dumps(data)))
             self.conn.commit()
             return True
         return False
@@ -72,98 +68,19 @@ class FilterCog(commands.Cog):
             notifyOnDelete=True
         )
 
+    @commands.hybrid_command()
+    async def importconfig(self, ctx, json_data: str):
+        """Import a configuration from a JSON string."""
+        try:
+            config_data = json.loads(json_data)
+            await self.config.guild(ctx.guild).set(config_data)
+            await ctx.send("Configuration imported successfully.")
+        except json.JSONDecodeError:
+            await ctx.send("Invalid JSON format.")
+
     @commands.Cog.listener()
     async def on_ready(self):
         print(f"{self.__class__.__name__} cog has been loaded.")
 
-    @commands.Cog.listener()
-    async def on_message(self, message):
-        if message.author.bot and not await self.config.deleteFromBots():
-            return
-        
-        if message.webhook_id and not await self.config.deleteFromWebhooks():
-            return
-        
-        if isinstance(message.channel, discord.DMChannel) and await self.config.ignorePrivateMessages():
-            return
-        
-        restrict_channel = await self.config.restrictToChannel()
-        if restrict_channel and message.channel.id != restrict_channel:
-            return
-        
-        words = self.storage.get(message.guild.id, "words")
-        case_sensitive = await self.config.caseSensitive()
-        message_content = message.content if case_sensitive else message.content.lower()
-        
-        for word in words:
-            word_check = word if case_sensitive else word.lower()
-            if word_check in message_content:
-                try:
-                    await message.delete()
-                    if await self.config.notifyOnDelete():
-                        embed = discord.Embed(title="Message Deleted", description=f"Your message was deleted because it contained a filtered word: `{word}`", color=discord.Color.red())
-                        await message.author.send(embed=embed)
-                    log_channel_id = await self.config.logChannelId()
-                    if log_channel_id:
-                        log_channel = message.guild.get_channel(log_channel_id)
-                        if log_channel:
-                            log_embed = discord.Embed(title="Filtered Message", description=f"Deleted a message from {message.author.mention} containing a filtered word: `{word}`", color=discord.Color.red())
-                            await log_channel.send(embed=log_embed)
-                    return
-                except discord.Forbidden:
-                    await message.channel.send("I don't have permission to delete messages.", delete_after=5)
-                except discord.HTTPException:
-                    print("Failed to delete message due to an HTTP error")
-
-    @commands.hybrid_group()
-    async def filter(self, ctx):
-        """Manage the filter system."""
-        await ctx.send_help(ctx.command)
-
-    @filter.command(name="addword")
-    async def addword(self, ctx, word: str):
-        """Add a word to the filter list."""
-        if self.storage.add(ctx.guild.id, "words", word):
-            await ctx.send(f"Added `{word}` to the filter list.")
-        else:
-            await ctx.send(f"`{word}` is already in the filter list.")
-
-    @filter.command(name="removeword")
-    async def removeword(self, ctx, word: str):
-        """Remove a word from the filter list."""
-        if self.storage.remove(ctx.guild.id, "words", word):
-            await ctx.send(f"Removed `{word}` from the filter list.")
-        else:
-            await ctx.send(f"`{word}` was not found in the filter list.")
-
-    @filter.command(name="listwords")
-    async def listwords(self, ctx):
-        """List all words in the filter."""
-        words = self.storage.get(ctx.guild.id, "words")
-        await ctx.send(f"Filtered words: {', '.join(words) if words else 'None'}")
-
-    @filter.command(name="clearwords")
-    async def clearwords(self, ctx):
-        """Clear all words from the filter list."""
-        self.storage.clear(ctx.guild.id, "words")
-        await ctx.send("All filtered words have been cleared.")
-
-    @filter.command(name="setlogchannel")
-    async def setlogchannel(self, ctx, channel: discord.TextChannel):
-        """Set the logging channel."""
-        await self.config.logChannelId.set(channel.id)
-        await ctx.send(f"Log channel set to {channel.mention}")
-
-    @filter.command(name="listautomodrules")
-    async def listautomodrules(self, ctx):
-        """List all AutoMod rules in the server."""
-        guild = ctx.guild
-        if guild:
-            rules = await guild.fetch_automod_rules()
-            rule_names = [rule.name for rule in rules]
-            await ctx.send(f"AutoMod Rules: {', '.join(rule_names) if rule_names else 'None'}")
-        else:
-            await ctx.send("This command must be used in a server.")
-
 async def setup(bot):
     await bot.add_cog(FilterCog(bot))