1.7.0: Mitmachen im Squad ohne Konto

Der Squad-Reiter braucht kein Konto mehr: Spielername eingeben, der PC
bekommt einen Schluessel (Token ohne Ablauf), die Akten werden fuer alle
sichtbar. E-Mail und Passwort sind optional ("Konto sichern") und machen
die Charaktere reset- und mehr-PC-fest. Ohne gesichertes Konto bietet das
Menue kein Abmelden, weil das den Schluessel loeschte.

Server: Aktionen mitmachen und konto_sichern, Konten ohne E-Mail
(Datenbank-Stand 2, eingespielt von DB::migrieren() bei der ersten
Anfrage), Loeschen ohne Passwort fuer reine Schluessel-Konten, Verwaltung
zeigt sie als "nur Schluessel". Deinstallationsfrage nennt den Schluessel.

Tests: Server 108, Zwei-PC 34, Oberflaeche 24 - auch gegen das Paket.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-09-15 06:35:54 +02:00
parent c175e42546
commit a5da53d373
14 changed files with 491 additions and 121 deletions

246
squad.py
View file

@ -1,9 +1,10 @@
"""
Hauptreiter SQUAD: Konto, alle Charaktere, Squads und Einladungen.
Ohne Anmeldung zeigt der Reiter die Anmeldung und Registrierung; alles
andere im Programm funktioniert auch ohne Konto. Angemeldet gibt es drei
Unterreiter:
Solange ein PC nicht mitmacht, zeigt der Reiter den Einstieg: Mitmachen mit
einem Spielernamen (der PC bekommt einen Schluessel, kein Konto noetig)
oder Anmelden mit einem gesicherten Konto. Alles andere im Programm geht
auch ohne. Wer mitmacht, sieht drei Unterreiter:
Charaktere alle Charaktere aller Spieler mit Zustand (KIA, MIA ...)
Squads alle Squads, eigene verwalten, neues gruenden
@ -92,8 +93,8 @@ class AbgleichSteuerung:
def melden(self, text=None, art="aus"):
if text is None:
text, art = ("Angemeldet – Abgleich folgt", "aus") if konto.angemeldet() \
else ("Nicht angemeldet – Akten liegen nur auf diesem PC", "aus")
text, art = ("Abgleich folgt", "aus") if konto.angemeldet() \
else ("Nur auf diesem PC – im Reiter SQUAD kannst du mitmachen", "aus")
for beobachter in self.beobachter:
beobachter(text, art)
@ -133,7 +134,8 @@ class AbgleichSteuerung:
def _fehler(self, fehler):
if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet":
self.melden("Die Anmeldung ist abgelaufen – bitte neu anmelden", "fehler")
self.melden("Der Server kennt diesen PC nicht mehr – im Reiter SQUAD neu mitmachen "
"oder anmelden", "fehler")
self.bei_abmeldung()
elif isinstance(fehler, konto.ServerFehler) and fehler.code == "offline":
self.melden("Offline – Änderungen werden später hochgeladen", "offline")
@ -154,6 +156,12 @@ class AbgleichSteuerung:
# -- Anmeldung und Registrierung ------------------------------------------------------
class AnmeldeFlaeche(ttk.Frame):
"""
Einstieg in den Squad-Reiter. Mitmachen braucht nur einen Spielernamen -
der PC bekommt einen Schluessel. Anmelden gibt es fuer gesicherte Konten,
etwa auf einem zweiten PC.
"""
def __init__(self, master, hintergrund, bei_anmeldung):
super().__init__(master)
self.hintergrund = hintergrund
@ -163,30 +171,30 @@ class AnmeldeFlaeche(ttk.Frame):
mitte = ttk.Frame(self)
mitte.place(relx=0.5, rely=0.42, anchor="center")
ttk.Label(mitte, text="SQUAD", font=("Segoe UI Semibold", 16)).pack(anchor="w")
ttk.Label(mitte, style="Dim.TLabel", justify="left", wraplength=420, text=(
"Mit einem Konto liegen deine Akten sicher auf dem Server, du siehst die "
"Charaktere der anderen Spieler und kannst Squads bilden. Ohne Konto "
"funktioniert alles andere wie bisher.")).pack(anchor="w", pady=(4, 14))
ttk.Label(mitte, style="Dim.TLabel", justify="left", wraplength=440, text=(
"Mach mit, um die Charaktere der anderen Spieler zu sehen und Squads zu bilden. "
"Deine Akten werden dann für alle sichtbar. Ein Konto brauchst du dafür nicht – "
"dieser PC bekommt einen eigenen Schlüssel.\n\n"
"Ohne Mitmachen bleiben deine Akten nur auf diesem PC.")).pack(anchor="w", pady=(4, 14))
reiter = ttk.Notebook(mitte)
reiter.pack(fill="x")
self.reiter = reiter
self._mitmachen_aufbauen(reiter)
self._anmelden_aufbauen(reiter)
self._registrieren_aufbauen(reiter)
self.meldung_var = tk.StringVar()
self.meldung = ttk.Label(mitte, textvariable=self.meldung_var, wraplength=420, justify="left")
self.meldung = ttk.Label(mitte, textvariable=self.meldung_var, wraplength=440, justify="left")
self.meldung.pack(anchor="w", pady=(12, 0))
self.erneut_knopf = ttk.Button(mitte, text="Bestätigungsmail erneut senden",
command=self.bestaetigung_erneut)
verweise = ttk.Frame(mitte)
verweise.pack(anchor="w", pady=(14, 0))
for text, pfad in (("Passwort vergessen?", None),
for text, ziel in (("Passwort vergessen?", konto.webseite("/konto/vergessen.php")),
("Impressum und Datenschutz", "https://tyrveil.com/rechtliches#impressum")):
verweis = ttk.Label(verweise, text=text, style="Dim.TLabel", cursor="hand2")
verweis.pack(side="left", padx=(0, 18))
ziel = pfad or konto.webseite("/konto/vergessen.php")
verweis.bind("<Button-1>", lambda e, z=ziel: webbrowser.open(z))
@staticmethod
@ -197,29 +205,31 @@ class AnmeldeFlaeche(ttk.Frame):
eingabe.grid(row=zeile, column=1, sticky="ew", pady=5)
return var, eingabe
def _mitmachen_aufbauen(self, reiter):
f = ttk.Frame(reiter, padding=16)
reiter.add(f, text="Mitmachen")
self.spielername_var, eingabe = self._feld(f, 0, "Spielername")
eingabe.bind("<Return>", lambda e: self.mitmachen())
ttk.Label(f, style="Dim.TLabel", wraplength=380, justify="left",
text="3 bis 32 Zeichen, etwa dein Discord- oder Steam-Name. Für alle sichtbar.").grid(
row=1, column=0, columnspan=2, sticky="w")
knopf = ttk.Button(f, text="Mitmachen", style="Accent.TButton", command=self.mitmachen)
knopf.grid(row=2, column=1, sticky="e", pady=(10, 0))
self._knoepfe.append(knopf)
def _anmelden_aufbauen(self, reiter):
f = ttk.Frame(reiter, padding=16)
reiter.add(f, text="Anmelden")
reiter.add(f, text="Mit Konto anmelden")
self.login_var, erstes = self._feld(f, 0, "Benutzername oder E-Mail")
self.passwort_var, pw = self._feld(f, 1, "Passwort", verdeckt=True)
ttk.Label(f, style="Dim.TLabel", wraplength=380, justify="left",
text="Für Konten, die mit E-Mail und Passwort gesichert sind – etwa auf einem zweiten PC."
).grid(row=2, column=0, columnspan=2, sticky="w")
knopf = ttk.Button(f, text="Anmelden", style="Accent.TButton", command=self.anmelden)
knopf.grid(row=2, column=1, sticky="e", pady=(10, 0))
knopf.grid(row=3, column=1, sticky="e", pady=(10, 0))
self._knoepfe.append(knopf)
for eingabe in (erstes, pw):
eingabe.bind("<Return>", lambda e: self.anmelden())
self.erstes_feld = erstes
def _registrieren_aufbauen(self, reiter):
f = ttk.Frame(reiter, padding=16)
reiter.add(f, text="Registrieren")
self.neu_name_var, _ = self._feld(f, 0, "Benutzername")
self.neu_email_var, _ = self._feld(f, 1, "E-Mail")
self.neu_pw_var, _ = self._feld(f, 2, "Passwort (mind. 10 Zeichen)", verdeckt=True)
self.neu_pw2_var, letztes = self._feld(f, 3, "Passwort wiederholen", verdeckt=True)
letztes.bind("<Return>", lambda e: self.registrieren())
knopf = ttk.Button(f, text="Konto anlegen", style="Accent.TButton", command=self.registrieren)
knopf.grid(row=4, column=1, sticky="e", pady=(10, 0))
self._knoepfe.append(knopf)
def _zeigen(self, text, art="info"):
farben = {"info": FG, "ok": OLIVE_HI, "fehler": RED, "warnung": AMBER}
@ -230,6 +240,25 @@ class AnmeldeFlaeche(ttk.Frame):
for knopf in self._knoepfe:
knopf.configure(state="disabled" if ja else "normal")
def mitmachen(self):
name = self.spielername_var.get().strip()
if not name:
self._zeigen("Bitte einen Spielernamen eingeben.", "warnung")
return
self._beschaeftigt(True)
self._zeigen("Einen Moment …")
def fertig(nutzer):
self._beschaeftigt(False)
self._zeigen("")
self.bei_anmeldung(nutzer)
def fehler(f):
self._beschaeftigt(False)
self._zeigen(fehlertext(f), "fehler")
self.hintergrund.starten(lambda: konto.mitmachen(name), fertig, fehler)
def anmelden(self):
login, passwort = self.login_var.get().strip(), self.passwort_var.get()
if not login or not passwort:
@ -262,33 +291,6 @@ class AnmeldeFlaeche(ttk.Frame):
lambda antwort: self._zeigen(antwort.get("meldung", "Mail ist unterwegs."), "ok"),
lambda f: self._zeigen(fehlertext(f), "fehler"))
def registrieren(self):
name, email = self.neu_name_var.get().strip(), self.neu_email_var.get().strip()
pw, pw2 = self.neu_pw_var.get(), self.neu_pw2_var.get()
if not name or not email or not pw:
self._zeigen("Bitte alle Felder ausfüllen.", "warnung")
return
if pw != pw2:
self._zeigen("Die beiden Passwörter stimmen nicht überein.", "warnung")
return
self._beschaeftigt(True)
self._zeigen("Lege Konto an …")
def fertig(antwort):
self._beschaeftigt(False)
self.neu_pw_var.set("")
self.neu_pw2_var.set("")
self.login_var.set(email)
self.reiter.select(0)
self._zeigen("Konto angelegt. Bitte bestätige den Link in der Mail an "
f"{email} – danach kannst du dich hier anmelden.", "ok")
def fehler(f):
self._beschaeftigt(False)
self._zeigen(fehlertext(f), "fehler")
self.hintergrund.starten(lambda: konto.registrieren(name, email, pw), fertig, fehler)
# -- Fremde Akte ansehen ----------------------------------------------------------------
@ -381,8 +383,7 @@ class SquadSeite(ttk.Frame):
if konto.angemeldet():
self.anmeldung.pack_forget()
self.inhalt.pack(fill="both", expand=True)
nutzer = konto.nutzer() or {}
self.nutzer_var.set(f"Angemeldet als {nutzer.get('benutzername', '?')}")
self._kopf_aktualisieren()
else:
self.inhalt.pack_forget()
self.anmeldung.pack(fill="both", expand=True)
@ -410,6 +411,101 @@ class SquadSeite(ttk.Frame):
self.hintergrund.starten(konto.abmelden, lambda _: self._abgemeldet(),
lambda f: self._abgemeldet())
# -- Konto --------------------------------------------------------------------------
def _kopf_aktualisieren(self):
nutzer = konto.nutzer() or {}
self.nutzer_var.set(f"Spieler: {nutzer.get('benutzername', '?')}")
if not nutzer.get("gesichert", True):
text = ("Deine Charaktere hängen nur am Schlüssel dieses PCs. Nach einem Reset wären sie "
"nicht mehr bearbeitbar – Konto sichern …")
elif not nutzer.get("bestaetigt", True):
text = "E-Mail-Adresse noch nicht bestätigt – den Link in der Mail öffnen. Erneut senden …"
else:
text = ""
self.sichern_text.configure(text=text)
if text:
self.sichern_zeile.pack(fill="x", pady=(0, 6), before=self.nb)
else:
self.sichern_zeile.pack_forget()
def _hinweis_geklickt(self):
nutzer = konto.nutzer() or {}
if not nutzer.get("gesichert", True):
self.konto_sichern()
elif not nutzer.get("bestaetigt", True):
self._bestaetigung_erneut()
def _konto_menue_fuellen(self):
menue = self.konto_menue
menue.delete(0, "end")
nutzer = konto.nutzer() or {}
if nutzer.get("gesichert", True):
if not nutzer.get("bestaetigt", True):
menue.add_command(label="Bestätigungsmail erneut senden", command=self._bestaetigung_erneut)
menue.add_command(label="Abmelden", command=self.abmelden)
else:
# Kein Abmelden: Das loeschte den Schluessel, und die Charaktere waeren verwaist
menue.add_command(label="Konto sichern …", command=self.konto_sichern)
menue.add_separator()
menue.add_command(label="Konto löschen …", command=self.konto_loeschen)
def _bestaetigung_erneut(self):
email = (konto.nutzer() or {}).get("email")
if email:
self.hintergrund.starten(lambda: konto.bestaetigung_erneut(email),
lambda _: self.status_var.set(f"Bestätigungsmail an {email} ist unterwegs."),
lambda f: messagebox.showerror("Konto", fehlertext(f), parent=self))
def konto_sichern(self):
"""E-Mail und Passwort an den Schluessel haengen."""
fenster = tk.Toplevel(self)
fenster.title("Konto sichern")
fenster.configure(bg=BG)
fenster.resizable(False, False)
fenster.transient(self.winfo_toplevel())
f = ttk.Frame(fenster, padding=18)
f.pack(fill="both")
ttk.Label(f, wraplength=400, justify="left", text=(
"Mit E-Mail und Passwort überstehen deine Charaktere einen PC-Reset, und du kannst "
"dich auch auf einem zweiten PC anmelden. Dein Spielername bleibt gleich.")).grid(
row=0, column=0, columnspan=2, sticky="w", pady=(0, 10))
felder = {}
for zeile, (schluessel, text, verdeckt) in enumerate((("email", "E-Mail", False),
("pw", "Passwort (mind. 10 Zeichen)", True),
("pw2", "Passwort wiederholen", True)), start=1):
ttk.Label(f, text=text).grid(row=zeile, column=0, sticky="w", pady=5, padx=(0, 12))
felder[schluessel] = tk.StringVar()
ttk.Entry(f, textvariable=felder[schluessel], width=32, show="•" if verdeckt else "").grid(
row=zeile, column=1, sticky="ew", pady=5)
meldung = ttk.Label(f, text="", foreground=RED, wraplength=400, justify="left")
meldung.grid(row=4, column=0, columnspan=2, sticky="w", pady=(6, 0))
def sichern():
email, pw = felder["email"].get().strip(), felder["pw"].get()
if pw != felder["pw2"].get():
meldung.configure(text="Die beiden Passwörter stimmen nicht überein.")
return
meldung.configure(text="Einen Moment …", foreground=FG_DIM)
def fertig(_):
fenster.destroy()
self._kopf_aktualisieren()
messagebox.showinfo("Konto sichern", f"Fast geschafft: Bestätige den Link in der Mail an {email}. "
"Danach kannst du dich auch auf anderen PCs mit E-Mail und Passwort anmelden.",
parent=self)
self.hintergrund.starten(lambda: konto.konto_sichern(email, pw), fertig,
lambda fehler: meldung.configure(text=fehlertext(fehler), foreground=RED))
knoepfe = ttk.Frame(f)
knoepfe.grid(row=5, column=0, columnspan=2, sticky="e", pady=(12, 0))
ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right")
ttk.Button(knoepfe, text="Sichern", style="Accent.TButton", command=sichern).pack(side="right", padx=(0, 8))
fenster.bind("<Escape>", lambda e: fenster.destroy())
dialog_zentrieren(fenster, self)
fenster.grab_set()
def konto_loeschen(self):
"""Loescht das Konto samt Akten auf dem Server. Die lokalen Akten bleiben."""
fenster = tk.Toplevel(self)
@ -424,14 +520,17 @@ class SquadSeite(ttk.Frame):
"deiner Charaktere ein Squad, übernimmt das dienstälteste Mitglied.\n\n"
"Deine Akten auf diesem PC bleiben erhalten. Das lässt sich nicht rückgängig machen.")
).grid(row=0, column=0, columnspan=2, sticky="w")
ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12))
passwort = tk.StringVar()
eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28)
eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0))
mit_passwort = konto.gesichert()
eingabe = None
if mit_passwort:
ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12))
eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28)
eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0))
def loeschen():
wert = passwort.get()
if wert:
if wert or not mit_passwort:
fenster.destroy()
self.konto_loeschen_ausfuehren(wert)
@ -442,7 +541,8 @@ class SquadSeite(ttk.Frame):
fenster.bind("<Escape>", lambda e: fenster.destroy())
dialog_zentrieren(fenster, self)
fenster.grab_set()
eingabe.focus_set()
if eingabe is not None:
eingabe.focus_set()
def konto_loeschen_ausfuehren(self, passwort, bestaetigen=True):
def arbeit():
@ -474,13 +574,18 @@ class SquadSeite(ttk.Frame):
self.nutzer_var = tk.StringVar()
ttk.Label(kopf, textvariable=self.nutzer_var, font=FONT_BOLD).pack(side="left")
konto_menue = ttk.Menubutton(kopf, text="Konto")
menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI,
activeforeground="#12150f", font=FONT_UI)
menue.add_command(label="Abmelden", command=self.abmelden)
menue.add_separator()
menue.add_command(label="Konto löschen …", command=self.konto_loeschen)
konto_menue["menu"] = menue
# Die Eintraege haengen davon ab, ob das Konto gesichert ist - beim Oeffnen neu fuellen
self.konto_menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI,
activeforeground="#12150f", font=FONT_UI,
postcommand=self._konto_menue_fuellen)
konto_menue["menu"] = self.konto_menue
konto_menue.pack(side="right")
# Solange das Konto nur am Schluessel dieses PCs haengt, daran erinnern
self.sichern_zeile = ttk.Frame(self.inhalt)
self.sichern_text = ttk.Label(self.sichern_zeile, foreground=AMBER, cursor="hand2", wraplength=820)
self.sichern_text.pack(side="left")
self.sichern_text.bind("<Button-1>", lambda e: self._hinweis_geklickt())
ttk.Button(kopf, text="Aktualisieren", command=self.aktualisieren).pack(side="right", padx=(0, 6))
self.status_var = tk.StringVar()
self.status = ttk.Label(kopf, textvariable=self.status_var, style="Dim.TLabel")
@ -489,6 +594,7 @@ class SquadSeite(ttk.Frame):
nb = ttk.Notebook(self.inhalt)
nb.pack(fill="both", expand=True)
self.nb = nb
self.sichern_zeile.pack(fill="x", pady=(0, 6), before=nb)
self._charaktere_aufbauen(nb)
self._squads_aufbauen(nb)
self._einladungen_aufbauen(nb)
@ -616,6 +722,7 @@ class SquadSeite(ttk.Frame):
fraktion = "" if self.fraktion_var.get() == ALLE_FRAKTIONEN else self.fraktion_var.get()
def arbeit():
konto.pruefen() # frischer Kontostand, etwa ob die E-Mail inzwischen bestaetigt ist
return (konto.aufrufen("charaktere_alle", suche=suche, fraktion=fraktion)["charaktere"],
konto.aufrufen("squads")["squads"],
konto.aufrufen("einladungen"))
@ -632,6 +739,7 @@ class SquadSeite(ttk.Frame):
def _geladen(self, ergebnis):
self._laedt = False
self._zuletzt_geladen = time.time()
self._kopf_aktualisieren()
self.charaktere, self.squads, einladungen = ergebnis
self.einladungen = {"eingang": einladungen.get("eingang", []), "ausgang": einladungen.get("ausgang", [])}
self.status_var.set(f"{len(self.charaktere)} Charaktere · {len(self.squads)} Squads · "