import sqlite3 import random from data.setup_database import DB_PATH def change_display_name(player_id, new_name): connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() cursor.execute("UPDATE players SET display_name = ? WHERE id = ?", (new_name, player_id)) connection.commit() connection.close() def generate_silly_name(): adjectives = ["Verwirrter", "Blinder", "Heulender", "Zorniger", "Chaos", "Verzweifelter", "Schreiender", "Stolpernder", "Schwitzender"] nouns = ["Grot", "Kultist", "Servitor", "Snotling", "Guardmen", "Würfellecker", "Regelvergesser", "Meta-Chaser", "Klebschnüffler"] adj = random.choice(adjectives) noun = random.choice(nouns) return f"{adj} {noun}" def get_or_create_player(discord_id, discord_name, avatar_url): connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # REPARIERT: Wir fragen 4 Dinge ab (id, discord_name, display_name, discord_avatar_url) cursor.execute("SELECT id, discord_name, display_name, discord_avatar_url FROM players WHERE discord_id = ?", (discord_id,)) player = cursor.fetchone() if player is None: # Random Silly Name Generator für neue Spieler. Damit sie angeregt werden ihren richtigen Namen einzutragen. silly_name = generate_silly_name() cursor.execute("INSERT INTO players (discord_id, discord_name, display_name, discord_avatar_url) VALUES (?, ?, ?, ?)", (discord_id, discord_name, silly_name, avatar_url)) connection.commit() cursor.execute("SELECT id, discord_name, display_name, discord_avatar_url FROM players WHERE discord_id = ?", (discord_id,)) player = cursor.fetchone() else: # Falls sich Name oder Bild auf Discord geändert haben, machen wir ein Update cursor.execute("UPDATE players SET discord_name = ?, discord_avatar_url = ? WHERE discord_id = ?", (discord_name, avatar_url, discord_id)) connection.commit() cursor.execute("SELECT id, discord_name, display_name, discord_avatar_url FROM players WHERE discord_id = ?", (discord_id,)) player = cursor.fetchone() connection.close() return player def get_all_players(): connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # Alle Spieler laden, absteigend sortiert nach MMR cursor.execute("SELECT id, name, mmr, points, games FROM players ORDER BY mmr DESC") players = cursor.fetchall() connection.close() # Die Daten für das Web-GUI in eine lesbare Form umwandeln (Liste von Dictionaries) result = [] return result def get_all_players_from_system(system_name): connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() # ID und Namen der Spieler. # DISTINCT stellt sicher, dass jeder Spieler nur einmal vorkommt. query = """ SELECT DISTINCT p.id AS player_id, p.display_name, p.discord_name FROM players p JOIN player_game_statistic stat ON p.id = stat.player_id JOIN gamesystems sys ON stat.gamesystem_id = sys.id WHERE sys.name = ? ORDER BY p.display_name ASC """ cursor.execute(query, (system_name,)) rows = cursor.fetchall() connection.close() result = [] for row in rows: result.append(dict(row)) return result def get_gamesystem_id_by_name(system_name): """Holt die interne ID eines Spielsystems anhand seines Namens (z.B. 'Warhammer 40k' -> 1).""" connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # Wir suchen exakt nach dem Namen cursor.execute("SELECT id FROM gamesystems WHERE name = ?", (system_name,)) row = cursor.fetchone() connection.close() # Wenn wir einen Treffer haben, geben wir die erste Spalte (die ID) zurück if row: return row[0] # Wenn das System nicht existiert return None def get_player_rank(player_id, gamesystem_id): """Sortiert die Liga nach MMR und gibt den aktuellen Platz (Rang) des Spielers zurück.""" connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() # Alle Spieler dieser Liga, sortiert nach MMR (höchstes zuerst) query = """ SELECT player_id FROM player_game_statistic WHERE gamesystem_id = ? ORDER BY mmr DESC """ cursor.execute(query, (gamesystem_id,)) rows = cursor.fetchall() connection.close() # Wir zählen die Liste durch (enumerate fängt bei 0 an, also machen wir +1 für den Rang) for index, row in enumerate(rows): if row['player_id'] == player_id: return index + 1 # Falls der Spieler nicht in der Liga ist (sollte nicht passieren) return 999 def get_gamesystem_data(): connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() cursor.execute("SELECT * FROM gamesystems") rows = cursor.fetchall() connection.close() # SQLite-Rows in normale Python-Dictionaries um result = [] for row in rows: result.append(dict(row)) return result def get_player_statistics(player_id): connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() query = """ SELECT sys.id AS gamesystem_id, sys.name AS gamesystem_name, sys.*, stat.mmr, stat.games_in_system, stat.points FROM gamesystems sys LEFT JOIN player_game_statistic stat ON sys.id = stat.gamesystem_id AND stat.player_id = ? """ cursor.execute(query, (player_id,)) rows = cursor.fetchall() connection.close() result = [] for row in rows: result.append(dict(row)) return result def join_league(player_id, gamesystem_id): connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # Wir fügen nur die beiden IDs ein, der Rest wird von den DEFAULT-Werten der DB erledigt query = """ INSERT INTO player_game_statistic (player_id, gamesystem_id) VALUES (?, ?) """ cursor.execute(query, (player_id, gamesystem_id)) connection.commit() connection.close() def get_recent_matches_for_player(player_id): connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() query = """ SELECT m.id AS match_id, sys.name AS gamesystem_name, m.player1_id, p1.display_name AS p1_display, p1.discord_name AS p1_discord, m.score_player1, m.player2_id, p2.display_name AS p2_display, p2.discord_name AS p2_discord, m.score_player2, m.played_at FROM matches m JOIN gamesystems sys ON m.gamesystem_id = sys.id JOIN players p1 ON m.player1_id = p1.id JOIN players p2 ON m.player2_id = p2.id WHERE m.player1_id = ? OR m.player2_id = ? ORDER BY m.played_at DESC LIMIT 10 """ cursor.execute(query, (player_id, player_id)) rows = cursor.fetchall() connection.close() result = [] for row in rows: result.append(dict(row)) return result def add_new_match(system_name, player1_id, player2_id, score_p1, score_p2): connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # 1. Wir suchen die interne ID des Spielsystems anhand des Namens (z.B. "Warhammer 40k" -> 1) cursor.execute("SELECT id FROM gamesystems WHERE name = ?", (system_name,)) sys_row = cursor.fetchone() # Sicherheitscheck (sollte eigentlich nie passieren) if not sys_row: connection.close() return None sys_id = sys_row[0] # 2. Das Match eintragen! (Datum 'played_at' macht SQLite durch DEFAULT CURRENT_TIMESTAMP automatisch) query = """ INSERT INTO matches (gamesystem_id, player1_id, player2_id, score_player1, score_player2) VALUES (?, ?, ?, ?, ?) """ cursor.execute(query, (sys_id, player1_id, player2_id, score_p1, score_p2)) new_match_id = cursor.lastrowid connection.commit() connection.close() return new_match_id def get_player_system_stats(player_id, system_name): """Holt die gespeicherten Statistiken eines Spielers für ein spezielles System direkt aus der Tabelle.""" connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() # stat.* holt einfach ALLE Spalten, die in der Tabelle player_game_statistic stehen query = """ SELECT stat.* FROM player_game_statistic stat JOIN gamesystems sys ON stat.gamesystem_id = sys.id WHERE stat.player_id = ? AND sys.name = ? """ cursor.execute(query, (player_id, system_name)) row = cursor.fetchone() connection.close() # Wenn wir was finden, machen wir ein Dictionary draus, ansonsten geben wir None zurück if row: return dict(row) return None def get_last_20_match_scores(player_id, system_name): """Holt die erspielten Punkte und das Datum der letzten 20 Matches.""" connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() # NEU: Wir haben 'm.played_at' im SELECT hinzugefügt! query = """ SELECT m.player1_id, m.score_player1, m.score_player2, m.played_at FROM matches m JOIN gamesystems sys ON m.gamesystem_id = sys.id WHERE sys.name = ? AND (m.player1_id = ? OR m.player2_id = ?) ORDER BY m.played_at DESC LIMIT 20 """ cursor.execute(query, (system_name, player_id, player_id)) rows = cursor.fetchall() connection.close() # Wieder umdrehen für den zeitlichen Verlauf (links alt, rechts neu) rows.reverse() points_list = [] labels_list = [] for row in rows: if row['player1_id'] == player_id: points_list.append(row['score_player1']) else: points_list.append(row['score_player2']) # NEU: Wir schneiden das Datum ab (z.B. 2024-03-04) und nutzen es als Label! date_clean = str(row['played_at'])[:10] labels_list.append(date_clean) return {"points": points_list, "labels": labels_list} def get_match_by_id(match_id): """Holt alle Daten eines spezifischen Matches anhand der Match-ID.""" connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row # Damit wir wieder ein schönes Dictionary bekommen cursor = connection.cursor() # m.* holt alle Spalten aus dem Match (Punkte, IDs, Datum) # sys.name AS gamesystem_name holt uns direkt den passenden Text für deine JSON-Ladefunktion query = """ SELECT m.*, sys.name AS gamesystem_name FROM matches m JOIN gamesystems sys ON m.gamesystem_id = sys.id WHERE m.id = ? """ cursor.execute(query, (match_id,)) row = cursor.fetchone() connection.close() # Wenn ein Match gefunden wurde, geben wir es als Dictionary zurück if row: return dict(row) return None # Falls die ID nicht existiert from datetime import datetime def get_days_since_last_game(player_id): """ Sucht das absolut letzte Spiel eines Spielers (über alle Systeme) und berechnet, wie viele Tage das her ist. """ connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # MAX(last_played) sucht den absolut neuesten Zeitstempel aus allen Einträgen dieses Spielers query = """ SELECT MAX(last_played) FROM player_game_statistic WHERE player_id = ? """ cursor.execute(query, (player_id,)) row = cursor.fetchone() connection.close() # row[0] enthält jetzt unseren Zeitstempel (z.B. '2026-03-05 14:30:00') last_played_str = row[0] if row else None # Sicherheitscheck: Hat der Spieler überhaupt schon Einträge? if not last_played_str: return None try: # [:19] schneidet Millisekunden ab, damit das Format exakt passt. last_played_date = datetime.strptime(last_played_str[:19], '%Y-%m-%d %H:%M:%S') # 2. Die Differenz zu "Jetzt genau in diesem Moment" berechnen time_difference = datetime.now() - last_played_date # 3. .days holt aus der Zeitdifferenz nur die reinen, vollen Tage heraus days_ago = time_difference.days return { "date_string": last_played_str[:10], # Nur das Datum (YYYY-MM-DD) für die GUI "days_ago": days_ago # Die nackte Zahl zum Rechnen (z.B. 14) } except ValueError: # Falls in der Datenbank mal ein kaputter String steht return None def apply_match_to_player_statistic (player_id, gamesystem_id, mmr_change, scored_points): connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # CURRENT_TIMESTAMP setzt die Uhrzeit für das "Letzte Spiel" automatisch auf genau JETZT. query = """ UPDATE player_game_statistic SET mmr = mmr + ?, games_in_system = games_in_system + 1, points = points + ?, avv_points = (points + ?) / (games_in_system + 1), last_played = CURRENT_TIMESTAMP WHERE player_id = ? AND gamesystem_id = ? """ # ACHTUNG: Wir müssen scored_points ZWEIMAL übergeben! # Einmal für die 'points' und einmal für die Berechnung der 'avv_points'. cursor.execute(query, (mmr_change, scored_points, scored_points, player_id, gamesystem_id)) connection.commit() connection.close() def get_leaderboard(system_name): """Holt alle Spieler eines Systems sortiert nach MMR für die Rangliste.""" connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() # WIR HABEN HIER EINE BEDINGUNG HINZUGEFÜGT: AND stat.games_in_system > 0 # Dadurch filtert die Datenbank direkt auf dem Server schon alle "0-Spiele"-Accounts raus. query = """ SELECT p.id, p.display_name, p.discord_name, stat.mmr FROM players p JOIN player_game_statistic stat ON p.id = stat.player_id JOIN gamesystems sys ON stat.gamesystem_id = sys.id WHERE sys.name = ? AND stat.games_in_system > 0 ORDER BY stat.mmr DESC """ cursor.execute(query, (system_name,)) rows = cursor.fetchall() connection.close() result = [] for row in rows: result.append(dict(row)) return result def update_match_mmr_change(match_id, p1_change, p2_change): """Speichert die tatsächliche MMR-Änderung für das Log fest im Match ab.""" connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() cursor.execute(""" UPDATE matches SET player1_mmr_change = ?, player2_mmr_change = ? WHERE id = ? """, (p1_change, p2_change, match_id)) connection.commit() connection.close() # ----------------------------------------------------- # Matches Bestätigen, Löschen, Berechnen, ... # ----------------------------------------------------- def get_unconfirmed_matches(player_id): """Holt alle offenen Matches, die der Spieler noch bestätigen muss.""" connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() # Wir joinen players (für den Namen des Gegners) und gamesystems (für den Systemnamen) query = """ SELECT m.id AS match_id, m.score_player1, m.score_player2, m.played_at, sys.name AS system_name, p1.display_name AS p1_name FROM matches m JOIN gamesystems sys ON m.gamesystem_id = sys.id JOIN players p1 ON m.player1_id = p1.id WHERE m.player2_id = ? AND m.player2_check = 0 """ cursor.execute(query, (player_id,)) rows = cursor.fetchall() connection.close() # Wir geben eine Liste mit Dictionaries zurück return [dict(row) for row in rows] def delete_match(match_id): """Löscht ein Match anhand seiner ID komplett aus der Datenbank.""" connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # DELETE FROM löscht die gesamte Zeile, bei der die ID übereinstimmt. cursor.execute("DELETE FROM matches WHERE id = ?", (match_id,)) connection.commit() connection.close() def confirm_match(match_id): connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # Ändert nur die Spalte player2_check auf 1 (True) cursor.execute("UPDATE matches SET player2_check = 1 WHERE id = ?", (match_id,)) connection.commit() connection.close() def set_match_counted(match_id): """Setzt den Haken (1), dass das Match erfolgreich in die MMR eingeflossen ist.""" connection = sqlite3.connect(DB_PATH) cursor = connection.cursor() # Ändert nur die Spalte match_is_counted auf 1 (True) cursor.execute("UPDATE matches SET match_is_counted = 1 WHERE id = ?", (match_id,)) connection.commit() connection.close() def get_submitted_matches(player_id): """Holt alle offenen Matches, die der Spieler selbst eingetragen hat, aber vom Gegner noch nicht bestätigt wurden.""" connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() # ACHTUNG: Wir joinen hier p2 (player2), weil wir den Namen des Gegners anzeigen wollen! query = """ SELECT m.id AS match_id, m.score_player1, m.score_player2, m.played_at, sys.name AS system_name, p2.display_name AS p2_name FROM matches m JOIN gamesystems sys ON m.gamesystem_id = sys.id JOIN players p2 ON m.player2_id = p2.id WHERE m.player1_id = ? AND m.player2_check = 0 """ cursor.execute(query, (player_id,)) rows = cursor.fetchall() connection.close() return [dict(row) for row in rows] def get_match_history_log(player_id): """Holt ALLE Matches eines Spielers inklusive der MMR-Änderungen für das Log.""" connection = sqlite3.connect(DB_PATH) connection.row_factory = sqlite3.Row cursor = connection.cursor() query = """ SELECT m.played_at, sys.name AS gamesystem_name, m.player1_id, p1.display_name AS p1_display, p1.discord_name AS p1_discord, m.score_player1, m.player1_mmr_change, m.player2_id, p2.display_name AS p2_display, p2.discord_name AS p2_discord, m.score_player2, m.player2_mmr_change, m.player2_check, m.match_is_counted FROM matches m JOIN gamesystems sys ON m.gamesystem_id = sys.id JOIN players p1 ON m.player1_id = p1.id JOIN players p2 ON m.player2_id = p2.id WHERE m.player1_id = ? OR m.player2_id = ? ORDER BY m.played_at DESC """ cursor.execute(query, (player_id, player_id)) rows = cursor.fetchall() connection.close() return [dict(row) for row in rows]