Skip to content
The Chat Archive
o1-mini-2024-09-12· OpenAI WildChat-4.8M (AI2)

Könntest du mir vielleicht dabei helfen, ein System zu machen in pycord 2.6? (Kein…

  1. User

    Könntest du mir vielleicht dabei helfen, ein System zu machen in pycord 2.6? (Kein import mit app_commands bitte) - Es soll in einer automoderationlist.py Cog sein,

    Es soll so aussehen:

    1. Es soll folgende Commands geben, die in einer SlashCommandGroup ("automod") sind:
    • /automod add word word: rule: (Leichter Verstoß, Mittlerer Verstoß, Schwerer Verstoß) action: (DM, Delete Message, Timeout), exeception: (Role), ping: (True/False)
    • /automod remove word word:
    • /automod show wordlist (Füge hier noch ein paar sinnvolle Commands hinzu)
    1. Alles soll überprüft werden und leistungsstark sein. Es soll dann in einen Kanal mit der ID "1279541671775698964" und dann die Rolle mit der ID "1268574837035761807" gepingt werden, wenn bei dem Command zugestimmt worden ist, dass es gepingt werden soll. Sonst nicht. Es sollen dort alle relevanten Informationen reingesendet werden sowie Buttons wie: "Nachrichten entfernen", "Akzeptieren", "Ablehnen" - Falls die Nachricht angenommen worden ist, wird eine Nachricht an den Nutzer gesendet in einem Embed Format, was ihm mitteilt, dass sein Inhalt nicht Regelkonform war und die Moderatoren sich dazu entschieden haben, diesen Beitrag zu entfernen. Erwähne auch Strafen, die auftreten können.

    2. Diese Commands sollen nur von Leuten ausgeführt werden dürfen, die "Manage Roles" Permissions haben.

  2. Assistant

    Natürlich kann ich dir dabei helfen, ein solches Automoderationssystem mit Pycord 2.6 zu erstellen. Im Folgenden findest du ein ausführliches Beispiel, das die beschriebenen Anforderungen erfüllt.

    Dieses Beispiel umfasst:

    1. Einrichten der Cog: automoderationlist.py
    2. Definieren der Slash-Command-Gruppe und ihrer Unterbefehle
    3. Datenverwaltung (Speicherung und Laden von Regeln)
    4. Interaktion mit einem spezifischen Kanal und Rollen
    5. Erstellen und Handhaben von Buttons
    6. Senden von Benachrichtigungen an Nutzer

    Voraussetzungen

    1. Pycord installieren:

      pip install py-cord
      
    2. Bot einrichten: Stelle sicher, dass dein Bot die folgenden Intents hat:

      • message_content
      • guilds
      • guild_messages
      • direct_messages
    3. Dateistruktur:

      • bot.py (Hauptdatei)
      • cogs/automoderationlist.py (Cog-Datei)

    1. Hauptbot-Datei (bot.py)

    Zunächst richten wir den Hauptbot ein und laden die Cog.

    import discord
    from discord.ext import commands
    import os
    
    intents = discord.Intents.default()
    intents.messages = True
    intents.guilds = True
    intents.message_content = True
    intents.members = True
    
    bot = commands.Bot(command_prefix="!", intents=intents)
    
    # Lädt alle Cogs aus dem cogs-Ordner
    @bot.event
    async def on_ready():
        print(f'Bot ist online als {bot.user}')
        for filename in os.listdir('./cogs'):
            if filename.endswith('.py'):
                await bot.load_extension(f'cogs.{filename[:-3]}')
    
    # Starte den Bot mit deinem Token
    bot.run('DEIN_BOT_TOKEN')
    

    2. Cog-Datei (cogs/automoderationlist.py)

    Diese Datei enthält alle Automoderationsfunktionen.

    import discord
    from discord.ext import commands
    from discord import app_commands
    import json
    import os
    
    # Pfad zur JSON-Datei für die Regelverwaltung
    DATA_FILE = 'automod_rules.json'
    
    # Stelle sicher, dass die JSON-Datei existiert
    if not os.path.exists(DATA_FILE):
        with open(DATA_FILE, 'w') as f:
            json.dump({"rules": []}, f, indent=4)
    
    def load_rules():
        with open(DATA_FILE, 'r') as f:
            return json.load(f)
    
    def save_rules(data):
        with open(DATA_FILE, 'w') as f:
            json.dump(data, f, indent=4)
    
    class AutomoderationList(commands.Cog):
        def __init__(self, bot):
            self.bot = bot
    
        # Erstelle eine Slash-Command-Gruppe namens 'automod'
        automod = app_commands.Group(name="automod", description="Automoderationsbefehle")
    
        # /automod add
        @automod.command(name="add", description="Füge ein Wort zur Automoderationsliste hinzu")
        @app_commands.describe(
            word="Das unerwünschte Wort",
            rule="Schwere des Verstoßes",
            action="Aktion bei Verstoß",
            exception="Ausnahme-Rolle",
            ping="Soll die Moderationsrolle gepingt werden?"
        )
        async def add(self, interaction: discord.Interaction, word: str, rule: str, action: str, exception: discord.Role = None, ping: bool = False):
            # Berechtigungsprüfung
            if not interaction.user.guild_permissions.manage_roles:
                await interaction.response.send_message("Du hast nicht die erforderlichen Berechtigungen (Manage Roles).", ephemeral=True)
                return
    
            # Validierung der Eingaben
            if rule.lower() not in ["leichter verstoß", "mittlerer verstoß", "schwerer verstoß"]:
                await interaction.response.send_message("Ungültige Regel. Optionen: Leichter Verstoß, Mittlerer Verstoß, Schwerer Verstoß.", ephemeral=True)
                return
    
            if action.lower() not in ["dm", "delete message", "timeout"]:
                await interaction.response.send_message("Ungültige Aktion. Optionen: DM, Delete Message, Timeout.", ephemeral=True)
                return
    
            data = load_rules()
    
            # Überprüfe, ob das Wort bereits existiert
            for rule_item in data["rules"]:
                if rule_item["word"].lower() == word.lower():
                    await interaction.response.send_message("Dieses Wort ist bereits in der Automoderationsliste.", ephemeral=True)
                    return
    
            # Füge die neue Regel hinzu
            new_rule = {
                "word": word.lower(),
                "rule": rule,
                "action": action,
                "exception": exception.id if exception else None,
                "ping": ping
            }
            data["rules"].append(new_rule)
            save_rules(data)
    
            await interaction.response.send_message(f'Die Regel für das Wort "{word}" wurde hinzugefügt.', ephemeral=True)
    
            # Sende eine Benachrichtigung an den spezifischen Kanal
            channel = self.bot.get_channel(1279541671775698964)
            if channel:
                embed = discord.Embed(title="Neue Automoderationsregel hinzugefügt", color=discord.Color.blue())
                embed.add_field(name="Wort", value=word, inline=False)
                embed.add_field(name="Regel", value=rule, inline=False)
                embed.add_field(name="Aktion", value=action, inline=False)
                if exception:
                    embed.add_field(name="Ausnahme-Rolle", value=exception.mention, inline=False)
                embed.add_field(name="Ping", value=str(ping), inline=False)
    
                components = [
                    discord.ui.Button(label="Nachrichten entfernen", style=discord.ButtonStyle.danger, custom_id="remove_messages"),
                    discord.ui.Button(label="Akzeptieren", style=discord.ButtonStyle.success, custom_id="accept"),
                    discord.ui.Button(label="Ablehnen", style=discord.ButtonStyle.secondary, custom_id="reject")
                ]
    
                if ping:
                    role = interaction.guild.get_role(1268574837035761807)
                    if role:
                        embed.description = f"{role.mention}"
                    else:
                        embed.description = "Rolle konnte nicht gefunden werden."
    
                await channel.send(embed=embed, components=components)
    
        # /automod remove
        @automod.command(name="remove", description="Entferne ein Wort aus der Automoderationsliste")
        @app_commands.describe(word="Das unerwünschte Wort, das entfernt werden soll")
        async def remove(self, interaction: discord.Interaction, word: str):
            # Berechtigungsprüfung
            if not interaction.user.guild_permissions.manage_roles:
                await interaction.response.send_message("Du hast nicht die erforderlichen Berechtigungen (Manage Roles).", ephemeral=True)
                return
    
            data = load_rules()
            initial_length = len(data["rules"])
            data["rules"] = [rule for rule in data["rules"] if rule["word"].lower() != word.lower()]
            if len(data["rules"]) < initial_length:
                save_rules(data)
                await interaction.response.send_message(f'Die Regel für das Wort "{word}" wurde entfernt.', ephemeral=True)
            else:
                await interaction.response.send_message(f'Die Regel für das Wort "{word}" wurde nicht gefunden.', ephemeral=True)
    
        # /automod show wordlist
        @automod.command(name="show", description="Zeige die aktuelle Wordlist")
        async def show(self, interaction: discord.Interaction):
            # Berechtigungsprüfung
            if not interaction.user.guild_permissions.manage_roles:
                await interaction.response.send_message("Du hast nicht die erforderlichen Berechtigungen (Manage Roles).", ephemeral=True)
                return
    
            data = load_rules()
            if not data["rules"]:
                await interaction.response.send_message("Die Automoderationsliste ist leer.", ephemeral=True)
                return
    
            embed = discord.Embed(title="Automoderationsliste", color=discord.Color.green())
            for rule_item in data["rules"]:
                exception = f"<@&{rule_item['exception']}>" if rule_item["exception"] else "Keine"
                embed.add_field(
                    name=rule_item["word"],
                    value=f"**Regel:** {rule_item['rule']}\n**Aktion:** {rule_item['action']}\n**Ausnahme-Rolle:** {exception}\n**Ping:** {rule_item['ping']}",
                    inline=False
                )
    
            await interaction.response.send_message(embed=embed, ephemeral=True)
    
        # Weitere sinnvolle Commands können hier hinzugefügt werden, z.B. um alle Regeln zu löschen, zu bearbeiten etc.
    
        # Event Listener für Nachrichten (automatische Moderation)
        @commands.Cog.listener()
        async def on_message(self, message):
            if message.author.bot:
                return
    
            data = load_rules()
            for rule in data["rules"]:
                if rule["word"] in message.content.lower():
                    # Überprüfe Ausnahmen
                    if rule["exception"]:
                        excluded = False
                        for role_id in rule["exception"]:
                            role = message.guild.get_role(role_id)
                            if role in message.author.roles:
                                excluded = True
                                break
                        if excluded:
                            continue
    
                    # Führe die Aktion aus
                    if rule["action"].lower() == "delete message":
                        await message.delete()
                        await self.notify_moderation(message, rule)
    
                    elif rule["action"].lower() == "dm":
                        try:
                            embed = discord.Embed(title="Automoderation", description=f"Dein Beitrag in **{message.guild.name}** wurde entfernt, da er gegen die Regeln verstößt.", color=discord.Color.red())
                            embed.add_field(name="Regel", value=rule["rule"], inline=False)
                            embed.add_field(name="Strafen", value="Weitere Verstöße können zu zeitweisen oder dauerhaften Strafen führen.", inline=False)
                            await message.author.send(embed=embed)
                        except:
                            pass  # Der Nutzer hat möglicherweise DMs deaktiviert
    
                    elif rule["action"].lower() == "timeout":
                        try:
                            await message.author.timeout(duration=60)  # Timeout für 1 Minute
                            embed = discord.Embed(title="Automoderation", description=f"Du wurdest für 1 Minute wegen eines Verstoßes gegen die Regeln zeitlich eingeschränkt.", color=discord.Color.orange())
                            await message.author.send(embed=embed)
                        except:
                            pass  # Möglicherweise keine Berechtigung
    
                    break  # Verhindert Mehrfachaktionen für mehrere Wörter
    
        async def notify_moderation(self, message, rule):
            channel = self.bot.get_channel(1279541671775698964)
            if not channel:
                return
    
            embed = discord.Embed(title="Nachricht entfernt", color=discord.Color.orange())
            embed.add_field(name="Benutzer", value=message.author.mention, inline=False)
            embed.add_field(name="Nachricht", value=message.content, inline=False)
            embed.add_field(name="Grund", value=f'Wort: "{rule["word"]}" - {rule["rule"]}', inline=False)
    
            components = [
                discord.ui.Button(label="Nachrichten entfernen", style=discord.ButtonStyle.danger, custom_id="remove_messages"),
                discord.ui.Button(label="Akzeptieren", style=discord.ButtonStyle.success, custom_id="accept"),
                discord.ui.Button(label="Ablehnen", style=discord.ButtonStyle.secondary, custom_id="reject")
            ]
    
            if rule["ping"]:
                role = message.guild.get_role(1268574837035761807)
                if role:
                    embed.description = f"{role.mention}"
    
            await channel.send(embed=embed, components=components)
    
        # Button-Handler
        @commands.Cog.listener()
        async def on_interaction(self, interaction: discord.Interaction):
            if not interaction.type == discord.InteractionType.component:
                return
    
            custom_id = interaction.data.get("custom_id")
            if custom_id in ["remove_messages", "accept", "reject"]:
                await interaction.response.defer()
                if custom_id == "remove_messages":
                    await interaction.message.delete()
                    await interaction.followup.send("Nachrichten wurden entfernt.", ephemeral=True)
                elif custom_id == "accept":
                    # Hier kannst du Logging oder andere Aktionen hinzufügen
                    await interaction.message.delete()
                    await interaction.followup.send("Nachricht akzeptiert und entfernt.", ephemeral=True)
                    # Informiere den Nutzer
                    user = interaction.message.embeds[0].fields[0].value  # Annahme: erster Feldwert ist der Nutzer
                    try:
                        embed = discord.Embed(title="Deine Nachricht wurde entfernt", description="Ein Moderator hat entschieden, deine Nachricht zu entfernen, da sie gegen die Serverregeln verstößt. Weitere Verstöße können zu strengeren Strafen führen.", color=discord.Color.red())
                        await interaction.guild.get_member(int(user)).send(embed=embed)
                    except:
                        pass
                elif custom_id == "reject":
                    await interaction.message.delete()
                    await interaction.followup.send("Ablehnung vermerkt.", ephemeral=True)
    
        # Weitere Event Listener oder Hilfsmethoden können hier hinzugefügt werden
    
    # Vergiss nicht, die Cog zu setzen
    async def setup(bot):
        await bot.add_cog(AutomoderationList(bot))
    

    3. Erklärung des Codes

    1. Datenverwaltung:

      • Die Regeln werden in einer JSON-Datei (automod_rules.json) gespeichert, um Persistenz sicherzustellen.
      • Funktionen load_rules und save_rules dienen zum Laden und Speichern der Regel-Daten.
    2. Befehle:

      • Add: Fügt ein neues Wort zur Automoderationsliste hinzu, inklusive Regel, Aktion, optionaler Ausnahme-Rolle und Ping-Option.
      • Remove: Entfernt ein Wort aus der Automoderationsliste.
      • Show: Zeigt die aktuelle Liste der moderierten Wörter an.
    3. Berechtigungsprüfung:

      • Alle Befehle überprüfen, ob der ausführende Benutzer die Berechtigung Manage Roles besitzt.
    4. Automatische Moderation:

      • Der Listener on_message überwacht Nachrichten und prüft sie gegen die Automoderationsregeln.
      • Bei einem Verstoß wird die entsprechend definierte Aktion ausgeführt (Nachricht löschen, DM senden, Timeout).
    5. Benachrichtigungen:

      • Bei Hinzufügen einer Regel wird eine Nachricht in einem spezifischen Kanal gesendet, inklusive Buttons für Moderationsaktionen.
      • Buttons ermöglichen es Moderatoren, schnell zu reagieren (Nachrichten entfernen, akzeptieren oder ablehnen).
    6. Button-Interaktionen:

      • Der Listener on_interaction behandelt die Button-Klicks und führt entsprechende Aktionen durch.

    4. Zusätzliche Hinweise

    • Error Handling: Es ist wichtig, Fehlerbehandlung hinzuzufügen, insbesondere bei Aktionen wie dem Senden von DMs oder dem Timeout, da diese fehlschlagen können (z.B. wenn der Nutzer DMs deaktiviert hat).

    • Erweiterungen: Du kannst weitere Befehle hinzufügen, wie z.B. das Bearbeiten bestehender Regeln oder das vollständige Zurücksetzen der Automoderationsliste.

    • Sicherheitsaspekte: Stelle sicher, dass die JSON-Datei vor unautorisiertem Zugriff geschützt ist und dass sensible Informationen nicht offengelegt werden.

    • Performance: Für eine größere Anzahl von Regeln und Servern könnte es effizienter sein, eine Datenbank wie SQLite oder eine NoSQL-Datenbank zu verwenden.

    5. Testen

    Nachdem du den Bot gestartet hast, kannst du die Befehle in deinem Discord-Server testen:

    • /automod add: Füge neue Automoderationsregeln hinzu.
    • /automod remove: Entferne bestehende Regeln.
    • /automod show: Zeige die aktuelle Liste der Regeln an.

    Stelle sicher, dass die Bot-Permissions korrekt gesetzt sind und dass der Bot Zugriff auf den spezifischen Kanal und die Rollen hat.

    Schlusswort

    Dieses Beispiel bietet eine robuste Grundlage für eine Automoderationslösung mit Pycord. Du kannst es weiter anpassen und erweitern, um den spezifischen Anforderungen deines Discord-Servers gerecht zu werden. Bei weiteren Fragen oder Anpassungswünschen stehe ich gerne zur Verfügung!