Discord-ai-chatbot/app.py

__version__ = "dev-0.4.6"
__all__ = ["Discordbot-chatai-webpanel (Discord)"]
__author__ = "SimolZimol"

from flask import Flask, render_template, redirect, url_for, request, session, jsonify, send_file, flash
from requests_oauthlib import OAuth2Session
import os
import subprocess
import psutil
import mysql.connector
from datetime import datetime

app = Flask(__name__)
app.secret_key = os.getenv("FLASK_SECRET_KEY")

LOG_FILE_PATH = os.path.join("logs", f"{datetime.now().strftime('%Y-%m-%d')}.log")

# Verwende Umgebungsvariablen aus Coolify für die Datenbankverbindung
DB_HOST = os.getenv("DB_HOST")
DB_PORT = os.getenv("DB_PORT")
DB_USER = os.getenv("DB_USER")
DB_PASS = os.getenv("DB_PASSWORD")
DB_NAME = os.getenv("DB_DATABASE")

DISCORD_CLIENT_ID = os.getenv("DISCORD_CLIENT_ID")
DISCORD_CLIENT_SECRET = os.getenv("DISCORD_CLIENT_SECRET")
DISCORD_REDIRECT_URI = os.getenv("DISCORD_REDIRECT_URI")
DISCORD_OAUTH2_URL = "https://discord.com/api/oauth2/authorize"
DISCORD_TOKEN_URL = "https://discord.com/api/oauth2/token"
DISCORD_API_URL = "https://discord.com/api/users/@me"
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'

# Globale Variablen für die Intros
INTRO_FILE = "introduction.txt"
ASKNOTES_INTRO_FILE = "asknotesintro.txt"

# Speichern der Prozess-ID
bot_process = None

def bot_status():
    """Überprüft, ob der Bot läuft."""
    global bot_process
    if bot_process is None:
        return False
    return bot_process.poll() is None  # None bedeutet, dass der Prozess noch läuft

def start_bot():
    """Startet den Bot."""
    global bot_process
    if not bot_status():
        bot_process = subprocess.Popen(["python", "bot.py"], cwd=os.path.dirname(os.path.abspath(__file__)))
    else:
        print("Bot läuft bereits.")

def stop_bot():
    """Stoppt den Bot."""
    global bot_process
    if bot_process and bot_status():
        bot_process.terminate()
        bot_process.wait()  # Warten, bis der Prozess beendet ist
        bot_process = None
    else:
        print("Bot läuft nicht.")

def load_text_file(file_path):
    """Lädt den Inhalt einer Textdatei."""
    if os.path.exists(file_path):
        with open(file_path, 'r', encoding='utf-8') as file:
            return file.read()
    return ""

def save_text_file(file_path, content):
    """Speichert den Inhalt in einer Textdatei."""
    with open(file_path, 'w', encoding='utf-8') as file:
        file.write(content)

def get_db_connection():
    """Stellt eine Verbindung zur MySQL-Datenbank her."""
    return mysql.connector.connect(
        host=DB_HOST,
        port=DB_PORT,
        user=DB_USER,
        password=DB_PASS,
        database=DB_NAME
    )

def make_discord_session(token=None, state=None):
    return OAuth2Session(
        DISCORD_CLIENT_ID,
        token=token,
        state=state,
        redirect_uri=DISCORD_REDIRECT_URI,
        scope=["identify"]
    )

def is_global_admin():
    """Überprüft, ob der Benutzer globale Admin-Rechte hat."""
    if "discord_user" in session:
        user_info = session["discord_user"]
        user_id = user_info["id"]
        
        # Überprüfe die globalen Admin-Rechte des Benutzers
        connection = get_db_connection()
        cursor = connection.cursor(dictionary=True)
        
        cursor.execute("SELECT global_permission FROM bot_data WHERE user_id = %s", (user_id,))
        user_data = cursor.fetchone()
        
        cursor.close()
        connection.close()
        
        if user_data and user_data["global_permission"] >= 8:
            return True
    return False

def is_server_admin(guild_id):
    """Überprüft, ob der Benutzer Admin-Rechte auf einem bestimmten Server (Guild) hat."""
    if "discord_user" in session:
        user_info = session["discord_user"]
        user_id = user_info["id"]
        
        connection = get_db_connection()
        cursor = connection.cursor(dictionary=True)
        
        cursor.execute("SELECT permission FROM user_data WHERE user_id = %s AND guild_id = %s", (user_id, guild_id))
        user_data = cursor.fetchone()
        
        cursor.close()
        connection.close()
        
        if user_data and user_data["permission"] >= 8:
            return True
    return False

@app.route("/")
def landing_page():
    """Ungeschützte Landing Page"""
    return render_template("landing.html")

@app.route("/login")
def login():
    """Startet den Discord-OAuth2-Flow."""
    discord = make_discord_session()
    authorization_url, state = discord.authorization_url(DISCORD_OAUTH2_URL)
    
    session['oauth_state'] = state
    return redirect(authorization_url)

@app.route("/callback")
def callback():
    """Verarbeitet den OAuth2-Rückruf von Discord."""
    discord = make_discord_session(state=session.get("oauth_state"))
    token = discord.fetch_token(
        DISCORD_TOKEN_URL,
        client_secret=DISCORD_CLIENT_SECRET,
        authorization_response=request.url,
    )
    
    session['oauth_token'] = token
    
    # User-Informationen von Discord abrufen
    user_info = discord.get(DISCORD_API_URL).json()
    
    # Speichere die Benutzerinformationen in der Session
    session['discord_user'] = user_info

    # Überprüfe, ob der Benutzer globale Admin-Rechte hat
    if is_global_admin():
        return redirect(url_for("global_admin_dashboard"))
    else:
        return redirect(url_for("select_guild"))

@app.route("/select_guild")
def select_guild():
    """Bietet dem Benutzer eine Liste der Server (Guilds), auf denen er Mitglied ist."""
    if "discord_user" in session:
        user_info = session["discord_user"]
        user_id = user_info["id"]
        
        connection = get_db_connection()
        cursor = connection.cursor(dictionary=True)
        
        cursor.execute("SELECT DISTINCT guild_id FROM user_data WHERE user_id = %s", (user_id,))
        guilds = cursor.fetchall()
        
        cursor.close()
        connection.close()

        return render_template("select_guild.html", guilds=guilds)
    return redirect(url_for("login"))

@app.route("/server_dashboard/<int:guild_id>")
def server_dashboard(guild_id):
    """Zeigt das Server-Admin-Dashboard an (nur für Admins eines bestimmten Servers)."""
    if is_server_admin(guild_id):
        connection = get_db_connection()
        cursor = connection.cursor(dictionary=True)

        # Hole Server-spezifische Daten (Giveaways, Punkte usw.)
        cursor.execute("SELECT * FROM giveaway_data WHERE guild_id = %s", (guild_id,))
        giveaways = cursor.fetchall()

        cursor.close()
        connection.close()

        return render_template("server_dashboard.html", guild_id=guild_id, giveaways=giveaways)
    return redirect(url_for("select_guild"))

@app.route("/global_admin_dashboard")
def global_admin_dashboard():
    """Zeigt das globale Admin-Dashboard an (nur für globale Admins)."""
    if is_global_admin():
        user_info = session["discord_user"]
        return render_template("global_admin_dashboard.html", user_info=user_info, bot_running=bot_status())
    return redirect(url_for("select_guild"))

@app.route("/start_bot")
def start():
    if is_global_admin():
        start_bot()
        user_info = session["discord_user"]
        return render_template("global_admin_dashboard.html", user_info=user_info, bot_running=bot_status())
    return redirect(url_for("landing_page"))

@app.route("/stop_bot")
def stop():
    if is_global_admin():
        stop_bot()
        user_info = session["discord_user"]
        return render_template("global_admin_dashboard.html", user_info=user_info, bot_running=bot_status())
    return redirect(url_for("landing_page"))

@app.route("/server_settings/<int:guild_id>", methods=["GET", "POST"])
def server_settings(guild_id):
    """Server-spezifische Einstellungen für den Server-Admin."""
    if is_server_admin(guild_id):
        if request.method == "POST":
            introduction = request.form.get("introduction")
            asknotes_introduction = request.form.get("asknotes_introduction")

            # Speichern der Intros
            save_text_file(INTRO_FILE, introduction)
            save_text_file(ASKNOTES_INTRO_FILE, asknotes_introduction)

            return redirect(url_for("server_settings", guild_id=guild_id))

        # Laden der aktuellen Inhalte aus den Textdateien
        introduction = load_text_file(INTRO_FILE)
        asknotes_introduction = load_text_file(ASKNOTES_INTRO_FILE)

        return render_template("server_settings.html", guild_id=guild_id, introduction=introduction, asknotes_introduction=asknotes_introduction)
    return redirect(url_for("select_guild"))

@app.route("/global_settings", methods=["GET", "POST"])
def global_settings():
    """Globale Einstellungen für den Bot-Admin."""
    if is_global_admin():
        if request.method == "POST":
            introduction = request.form.get("introduction")
            asknotes_introduction = request.form.get("asknotes_introduction")

            # Speichern der Intros
            save_text_file(INTRO_FILE, introduction)
            save_text_file(ASKNOTES_INTRO_FILE, asknotes_introduction)

            return redirect(url_for("global_settings"))

        # Laden der aktuellen Inhalte aus den Textdateien
        introduction = load_text_file(INTRO_FILE)
        asknotes_introduction = load_text_file(ASKNOTES_INTRO_FILE)

        return render_template("global_settings.html", introduction=introduction, asknotes_introduction=asknotes_introduction)
    return redirect(url_for("global_admin_dashboard"))

@app.route("/logout")
def logout():
    """Löscht die Benutzersitzung und meldet den Benutzer ab."""
    session.pop('discord_user', None)
    session.pop('oauth_token', None)
    return redirect(url_for('landing_page'))

@app.route("/server_giveaways/<int:guild_id>")
def server_giveaways(guild_id):
    """Zeigt die Giveaways für einen spezifischen Server an."""
    if is_server_admin(guild_id):
        connection = get_db_connection()
        cursor = connection.cursor(dictionary=True)
        
        cursor.execute("SELECT * FROM giveaway_data WHERE guild_id = %s", (guild_id,))
        giveaways = cursor.fetchall()
        
        cursor.close()
        connection.close()

        return render_template("server_giveaways.html", guild_id=guild_id, giveaways=giveaways)
    return redirect(url_for("select_guild"))

@app.route("/global_giveaways", methods=["GET", "POST"])
def global_giveaways():
    """Zeigt globale Giveaways an und ermöglicht globale Änderungen."""
    if is_global_admin():
        connection = get_db_connection()
        cursor = connection.cursor(dictionary=True)

        sort_field = request.args.get("sort", "id")  # Standardmäßig nach 'id' sortieren
        order = request.args.get("order", "asc")  # Standardmäßig aufsteigend sortieren

        cursor.execute(f"SELECT * FROM giveaway_data ORDER BY {sort_field} {order}")
        giveaways = cursor.fetchall()
        
        cursor.close()
        connection.close()

        return render_template("global_giveaways.html", giveaways=giveaways)
    return redirect(url_for("global_admin_dashboard"))

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000, debug=True)