ManagerX V2.0.0 – Update

.github/workflows/label.yml

@@ -12,10 +12,10 @@ jobs:
 
     steps:
     # Schritt 1: Fügt den Checkout-Schritt hinzu, um die Dateien lokal abzurufen
-    - uses: actions/checkout@v4 
+    - uses: actions/checkout@v6 
 
     # Schritt 2: Führt den Labeler aus.
-    - uses: actions/labeler@v5
+    - uses: actions/labeler@v6
       with:
         # configuration-path ist jetzt optional, aber sicherheitshalber belassen wir ihn
         configuration-path: .github/labeler.yml

.github/workflows/static.yml

@@ -2,7 +2,7 @@
 name: Deploy static content to Pages
 
 on:
-  # Runs on pushes targeting the default branch
+  # Runs on pushes targeting the 2.0.0 branch
   push:
     branches: ["2.0.0"]
 
@@ -15,29 +15,29 @@ permissions:
   pages: write
   id-token: write
 
-# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
-# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+# Allow only one concurrent deployment
 concurrency:
   group: "pages"
   cancel-in-progress: false
 
 jobs:
-  # Single deploy job since we're just deploying
   deploy:
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6 # Updated to stable v4
+
       - name: Setup Pages
         uses: actions/configure-pages@v5
+
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
+        uses: actions/upload-pages-artifact@v4
         with:
-          # Upload entire repository
-          path: 'site'
+          # This points to your specific folder
+          path: 'site/'
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v4

.gitignore

@@ -27,6 +27,7 @@ DevTools/backend/utils/config.py
 command.yaml
 wiki_stats.json
 checker.py
+bot_stats.json
 
 # Build-Ordner: alles ignorieren...
 _build/*
@@ -39,13 +40,4 @@ docs/_build/html/_sources/
 furo.js.LICENSE.txt
 fontawesome.js.LICENSE.txt
 .map
-docs/_build/doctrees/
-
-
-# ...außer HTML & CSS im html-Ordner
-!_build/html/
-!_build/html/**/*.html
-!_build/html/**/*.css
-!_build/html/_static/
-!_build/html/_static/**/*.css
-!_build/html/_static/**/*.js
+docs/_build/*

.readthedocs.yaml

@@ -1,13 +1,26 @@
+
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
 version: 2
 
+# Set the OS, Python version, and other tools you might need
 build:
   os: ubuntu-24.04
   tools:
     python: "3.12"
 
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+   configuration: docs/conf.py
+
+# Optionally, but recommended,
+# declare the Python requirements required to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+# python:
+#    install:
+#    - requirements: docs/requirements.txt
 python:
   install:
-    - requirements: docs/req.txt  # <- hier die Datei für die Docs
-
-sphinx:
-  configuration: docs/conf.py  # Pfad zu deiner conf.py
+    - requirements: requirements/docs_req.txt

src/DevTools/backend/__init__.py → DevTools/backend/__init__.py

@@ -2,6 +2,4 @@
 
 from .config import *
 
-from .utils import *
-
 from .logging import *

src/DevTools/backend/database/__init__.py → DevTools/backend/database/__init__.py

@@ -4,8 +4,10 @@
 from .spam_db import *
 from .notes_db import *
 from .Stats_db import *
-from .globalchat_db import db as globalchat_db
+from .globalchat_db import db as GlobalChatDatabase
 from .levelsystem_db import *
 from .logging_db import *
 from .autodelete_db import *
-from .welcome_db import *
+from .welcome_db import *
+from .lang_db import *
+from .autorole_db import AutoRoleDatabase

DevTools/backend/database/autorole_db.py

@@ -0,0 +1,102 @@
+import aiosqlite
+import random
+import string
+import os
+
+class AutoRoleDatabase:
+    def __init__(self, db_path="data/autorole.db"):
+        self.db_path = db_path
+        # Erstellt den Ordner 'data', falls er fehlt
+        directory = os.path.dirname(self.db_path)
+        if directory and not os.path.exists(directory):
+            os.makedirs(directory, exist_ok=True)
+
+    async def init_db(self):
+        """Erstellt die Tabelle, falls sie noch nicht existiert"""
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS autoroles (
+                    autorole_id TEXT PRIMARY KEY,
+                    guild_id INTEGER NOT NULL,
+                    role_id INTEGER NOT NULL,
+                    enabled INTEGER DEFAULT 1,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            await db.commit()
+
+    def generate_autorole_id(self, guild_id: int, role_id: int):
+        guild_part = str(guild_id)[-2:].zfill(2)
+        role_part = str(role_id)[-2:].zfill(2)
+        random_part = ''.join(random.choices(string.digits, k=3))
+        return f"{guild_part}-{role_part}-{random_part}"
+
+    async def add_autorole(self, guild_id: int, role_id: int):
+        # WICHTIG: Erst sicherstellen, dass die Tabelle da ist!
+        await self.init_db()
+
+        autorole_id = self.generate_autorole_id(guild_id, role_id)
+
+        async with aiosqlite.connect(self.db_path) as db:
+            # Check ob ID existiert
+            while True:
+                async with db.execute(
+                    "SELECT autorole_id FROM autoroles WHERE autorole_id = ?",
+                    (autorole_id,)
+                ) as cursor:
+                    if not await cursor.fetchone():
+                        break
+                    autorole_id = self.generate_autorole_id(guild_id, role_id)
+
+            await db.execute("""
+                INSERT INTO autoroles (autorole_id, guild_id, role_id, enabled)
+                VALUES (?, ?, ?, 1)
+            """, (autorole_id, guild_id, role_id))
+            await db.commit()
+
+        return autorole_id
+
+    async def get_all_autoroles(self, guild_id: int):
+        await self.init_db()
+        async with aiosqlite.connect(self.db_path) as db:
+            async with db.execute(
+                "SELECT autorole_id, role_id, enabled FROM autoroles WHERE guild_id = ?", 
+                (guild_id,)
+            ) as cursor:
+                rows = await cursor.fetchall()
+                return [{"autorole_id": r[0], "role_id": r[1], "enabled": bool(r[2])} for r in rows]
+
+    async def get_autorole(self, autorole_id: str):
+        await self.init_db()
+        async with aiosqlite.connect(self.db_path) as db:
+            async with db.execute(
+                "SELECT autorole_id, guild_id, role_id, enabled FROM autoroles WHERE autorole_id = ?", 
+                (autorole_id,)
+            ) as cursor:
+                row = await cursor.fetchone()
+                return {"autorole_id": row[0], "guild_id": row[1], "role_id": row[2], "enabled": bool(row[3])} if row else None
+
+    async def get_enabled_autoroles(self, guild_id: int):
+        await self.init_db()
+        async with aiosqlite.connect(self.db_path) as db:
+            async with db.execute(
+                "SELECT role_id FROM autoroles WHERE guild_id = ? AND enabled = 1", 
+                (guild_id,)
+            ) as cursor:
+                rows = await cursor.fetchall()
+                return [r[0] for r in rows]
+
+    async def remove_autorole(self, autorole_id: str):
+        await self.init_db()
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("DELETE FROM autoroles WHERE autorole_id = ?", (autorole_id,))
+            await db.commit()
+
+    async def toggle_autorole(self, autorole_id: str, enabled: bool):
+        await self.init_db()
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute(
+                "UPDATE autoroles SET enabled = ? WHERE autorole_id = ?", 
+                (1 if enabled else 0, autorole_id)
+            )
+            await db.commit()

DevTools/backend/database/lang_db.py

@@ -0,0 +1,46 @@
+# src/database/settings_db.py
+
+import sqlite3
+import os
+from datetime import datetime
+
+class SettingsDB:
+    """
+    Datenbank-Klasse zur Verwaltung von Benutzer- und Servereinstellungen.
+    """
+    def __init__(self, db_path="data/settings.db"):
+        self.db_path = db_path
+        os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+        self.conn = sqlite3.connect(self.db_path)
+        self.cursor = self.conn.cursor()
+        self.create_tables()
+        print(f"[{datetime.now().strftime('%H:%M:%S')}] [DATABASE] Settings Database initialized ✓")
+
+    def create_tables(self):
+        """Erstellt die Benutzereinstellungen-Tabelle, falls sie nicht existiert."""
+        self.cursor.execute("""
+            CREATE TABLE IF NOT EXISTS user_settings (
+                user_id INTEGER PRIMARY KEY,
+                language TEXT NOT NULL DEFAULT 'en'
+            )
+        """)
+        self.conn.commit()
+
+    def set_user_language(self, user_id: int, lang_code: str):
+        """Speichert den Sprachcode für einen Benutzer."""
+        self.cursor.execute("""
+            INSERT OR REPLACE INTO user_settings (user_id, language)
+            VALUES (?, ?)
+        """, (user_id, lang_code))
+        self.conn.commit()
+
+    def get_user_language(self, user_id: int) -> str:
+        """Ruft den Sprachcode für einen Benutzer ab. Standard: 'en'."""
+        self.cursor.execute("SELECT language FROM user_settings WHERE user_id = ?", (user_id,))
+        result = self.cursor.fetchone()
+
+        # 'en' als gewünschter Standard, falls kein Eintrag gefunden wird
+        return result[0] if result else 'en'
+
+    def close(self):
+        self.conn.close()

DevTools/backend/utils/__init__.py

@@ -0,0 +1 @@
+from .config import *