Der ultimative Guide: So erstellst du ein Discord Bot Warn System mit eigener Datenbank

Discord ist mehr als nur eine Kommunikationsplattform; es ist das Herzstück vieler Communities. Um diese Communities aktiv und sicher zu halten, sind Moderationstools unerlässlich. Ein Warnsystem, das von einem Discord Bot betrieben wird und auf einer eigenen Datenbank basiert, ist ein mächtiges Werkzeug, um Regelverstöße zu ahnden und das Verhalten der Mitglieder zu lenken. In diesem umfassenden Leitfaden zeigen wir dir, wie du ein solches System von Grund auf aufbaust.

Warum ein eigenes Warnsystem mit Datenbank?

Es gibt viele vorgefertigte Discord Bots mit Warnsystemen. Warum also die Mühe, ein eigenes zu erstellen? Hier sind einige Gründe:

• Vollständige Kontrolle: Du hast die volle Kontrolle über das Design, die Funktionalität und die Datenhaltung.
• Anpassbarkeit: Passe das System an die spezifischen Bedürfnisse deiner Community an.
• Lerneffekt: Du lernst programmieren und Datenbankmanagement.
• Datenschutz: Du bestimmst, wie die Daten gespeichert und verarbeitet werden.
• Integration: Du kannst das System nahtlos in andere Teile deines Discord Bots integrieren.

Die Grundlagen: Was du brauchst

Bevor wir loslegen, stelle sicher, dass du Folgendes hast:

• Programmierkenntnisse: Grundkenntnisse in Python (oder einer anderen Sprache, die Discord Bot Entwicklung unterstützt).
• Python Umgebung: Eine installierte Python Umgebung mit pip.
• Discord Bot Token: Einen Discord Bot Token. Du erhältst diesen, indem du einen Bot in deinem Discord Developer Portal erstellst.
• Texteditor oder IDE: Ein Texteditor oder eine integrierte Entwicklungsumgebung (IDE) deiner Wahl (z.B. VS Code, PyCharm).
• Datenbank: Eine Datenbank deiner Wahl (z.B. SQLite, PostgreSQL, MySQL). Wir verwenden in diesem Tutorial SQLite für die Einfachheit.
• Discord.py Bibliothek: Installiere die Discord.py Bibliothek mit `pip install discord.py`.
• Datenbank Bibliothek: Installiere die passende Bibliothek für deine Datenbank (z.B. `pip install sqlite3` für SQLite).

Schritt 1: Die Datenbankstruktur

Eine gut strukturierte Datenbank ist das Fundament unseres Warnsystems. Wir erstellen eine Tabelle, um die Warnungen zu speichern. Für SQLite könnte das so aussehen:

„`sql
CREATE TABLE warnings (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL,
guild_id INTEGER NOT NULL,
moderator_id INTEGER NOT NULL,
reason TEXT,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
);
„`

Hier die Erklärungen zu den Spalten:

• id: Eindeutige ID der Warnung (Primärschlüssel).
• user_id: ID des gewarnten Benutzers.
• guild_id: ID des Servers, in dem die Warnung ausgesprochen wurde.
• moderator_id: ID des Moderators, der die Warnung ausgesprochen hat.
• reason: Der Grund für die Warnung.
• timestamp: Der Zeitpunkt, an dem die Warnung ausgesprochen wurde.

Schritt 2: Die Datenbankverbindung

Als Nächstes erstellen wir eine Funktion, um uns mit der Datenbank zu verbinden:

„`python
import sqlite3
import discord
from discord.ext import commands

# Konfiguration
DATABASE_PATH = ‘warnings.db’ # Pfad zur Datenbankdatei
TOKEN = ‘DEIN_BOT_TOKEN’ # Ersetze dies mit deinem Bot Token
PREFIX = ‘!’ # Präfix für die Bot-Befehle

# Erstelle eine Verbindung zur Datenbank
def create_connection():
conn = None
try:
conn = sqlite3.connect(DATABASE_PATH)
print(„Verbindung zur Datenbank hergestellt”)
except sqlite3.Error as e:
print(f”Fehler beim Verbinden mit der Datenbank: {e}”)
return conn

# Erstelle die Tabelle, falls sie noch nicht existiert
def create_table(conn):
try:
cursor = conn.cursor()
cursor.execute(„””
CREATE TABLE IF NOT EXISTS warnings (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL,
guild_id INTEGER NOT NULL,
moderator_id INTEGER NOT NULL,
reason TEXT,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
)
„””)
conn.commit()
print(„Tabelle ‘warnings’ erstellt (falls nicht vorhanden)”)
except sqlite3.Error as e:
print(f”Fehler beim Erstellen der Tabelle: {e}”)
„`

Schritt 3: Der Discord Bot

Jetzt erstellen wir den Discord Bot mit Discord.py:

„`python
bot = commands.Bot(command_prefix=PREFIX, intents=discord.Intents.all())

@bot.event
async def on_ready():
print(f’Eingeloggt als {bot.user.name}’)

@bot.command(name=’warn’)
@commands.has_permissions(kick_members=True)
async def warn(ctx, member: discord.Member, *, reason=None):
„””Warnt einen Benutzer.”””
conn = create_connection()
if conn:
try:
cursor = conn.cursor()
cursor.execute(„INSERT INTO warnings (user_id, guild_id, moderator_id, reason) VALUES (?, ?, ?, ?)”,
(member.id, ctx.guild.id, ctx.author.id, reason))
conn.commit()
await ctx.send(f'{member.mention} wurde gewarnt. Grund: {reason}’)

# Optional: Sende dem Benutzer eine private Nachricht
try:
await member.send(f’Du wurdest auf dem Server {ctx.guild.name} gewarnt. Grund: {reason}’)
except discord.errors.Forbidden:
await ctx.send(f”Konnte {member.mention} keine private Nachricht senden.”)

except sqlite3.Error as e:
print(f”Fehler beim Hinzufügen der Warnung zur Datenbank: {e}”)
await ctx.send(„Fehler beim Speichern der Warnung.”)
finally:
conn.close()
else:
await ctx.send(„Konnte keine Verbindung zur Datenbank herstellen.”)

@bot.command(name=’warnings’)
async def warnings(ctx, member: discord.Member = None):
„””Zeigt die Warnungen eines Benutzers an.”””
conn = create_connection()
if conn:
try:
if member is None:
member = ctx.author
cursor = conn.cursor()
cursor.execute(„SELECT * FROM warnings WHERE user_id = ? AND guild_id = ?”, (member.id, ctx.guild.id))
warnings = cursor.fetchall()

if not warnings:
await ctx.send(f'{member.mention} hat keine Warnungen.’)
else:
embed = discord.Embed(title=f’Warnungen für {member.name}’, color=discord.Color.orange())
for warning in warnings:
embed.add_field(name=f’Warnung ID: {warning[0]}’, value=f’Moderator: <@{warning[3]}>nGrund: {warning[4]}nZeitpunkt: {warning[5]}’, inline=False)
await ctx.send(embed=embed)

except sqlite3.Error as e:
print(f”Fehler beim Abrufen der Warnungen aus der Datenbank: {e}”)
await ctx.send(„Fehler beim Abrufen der Warnungen.”)
finally:
conn.close()
else:
await ctx.send(„Konnte keine Verbindung zur Datenbank herstellen.”)

@bot.command(name=’clearwarns’)
@commands.has_permissions(administrator=True)
async def clearwarns(ctx, member: discord.Member):
„””Löscht alle Warnungen eines Benutzers.”””
conn = create_connection()
if conn:
try:
cursor = conn.cursor()
cursor.execute(„DELETE FROM warnings WHERE user_id = ? AND guild_id = ?”, (member.id, ctx.guild.id))
conn.commit()
await ctx.send(f’Alle Warnungen von {member.mention} wurden gelöscht.’)
except sqlite3.Error as e:
print(f”Fehler beim Löschen der Warnungen aus der Datenbank: {e}”)
await ctx.send(„Fehler beim Löschen der Warnungen.”)
finally:
conn.close()
else:
await ctx.send(„Konnte keine Verbindung zur Datenbank herstellen.”)

# Starte den Bot
conn = create_connection()
if conn:
create_table(conn)
conn.close()
bot.run(TOKEN)

„`

Schritt 4: Erläuterung des Codes

Lass uns den Code genauer betrachten:

• `@bot.event` on_ready: Dieser Event wird ausgelöst, wenn sich der Bot erfolgreich bei Discord eingeloggt hat.
• `@bot.command(name=’warn’)`: Dies ist der `warn`-Befehl, mit dem Moderatoren Benutzer warnen können. `@commands.has_permissions(kick_members=True)` stellt sicher, dass nur Benutzer mit der Berechtigung zum Kicken von Mitgliedern diesen Befehl ausführen können.
• `@bot.command(name=’warnings’)`: Dies ist der `warnings`-Befehl, um die Warnungen eines Benutzers abzurufen.
• `@bot.command(name=’clearwarns’)`: Dies ist der `clearwarns`-Befehl, um die Warnungen eines Benutzers zu löschen. `@commands.has_permissions(administrator=True)` stellt sicher, dass nur Administratoren diesen Befehl ausführen können.
• Die Datenbankinteraktionen (Einfügen, Abrufen, Löschen) werden innerhalb der try-except-finally Blöcke behandelt, um sicherzustellen, dass die Verbindung zur Datenbank immer ordnungsgemäß geschlossen wird, auch wenn Fehler auftreten.

Schritt 5: Erweiterungen und Verbesserungen

Dieses Warnsystem ist ein guter Ausgangspunkt. Hier sind einige Ideen, wie du es erweitern kannst:

• Automatische Strafen: Richte automatische Strafen ein, wenn ein Benutzer eine bestimmte Anzahl von Warnungen erhält (z.B. Stummschaltung, Kick, Bann).
• Logging: Protokolliere alle Warnungen in einem separaten Kanal zur besseren Nachverfolgung.
• Web-Dashboard: Erstelle ein Web-Dashboard, um Warnungen zu verwalten und Statistiken anzuzeigen.
• Verschiedene Warnstufen: Implementiere verschiedene Warnstufen mit unterschiedlichen Auswirkungen.
• Bessere Fehlerbehandlung: Implementiere eine detailliertere Fehlerbehandlung und Logging.

Fazit

Ein eigenes Discord Bot Warnsystem mit einer Datenbank zu erstellen, mag zunächst komplex erscheinen, aber es ist eine lohnende Aufgabe. Du erhältst nicht nur ein mächtiges Moderationstool, sondern erweiterst auch deine Programmierkenntnisse und hast die volle Kontrolle über deine Daten. Mit diesem Leitfaden hast du die Grundlagen, um loszulegen. Viel Erfolg!