squad-manager/squad.py
danny a5da53d373 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>
2026-09-15 06:35:54 +02:00

1053 lines
49 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""
Hauptreiter SQUAD: Konto, alle Charaktere, Squads und Einladungen.
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
Einladungen erhaltene annehmen oder ablehnen, verschickte zurueckziehen
Dazu steuert AbgleichSteuerung, wann die eigenen Akten mit dem Server
abgeglichen werden. Alle Serveraufrufe laufen ueber hintergrund.py, damit
das Fenster nie einfriert.
"""
import io
import time
import tkinter as tk
import webbrowser
from tkinter import messagebox, ttk
from PIL import Image, ImageOps, ImageTk
import abgleich
import akte
import akte_modell as modell
import akte_vorlagen as vorlagen
import konto
from hintergrund import Hintergrund
from theme import (AMBER, BG, FG, FG_DIM, FONT_BOLD, FONT_UI, OLIVE_HI, PANEL, RED,
dunkle_titelleiste)
ALLE_FRAKTIONEN = "Alle Fraktionen"
ZUSTAND = {
"aktiv": ("", "aktiv"),
"verwundet": ("WIA", "verwundet"),
"vermisst": ("MIA", "vermisst"),
"gefallen": ("KIA", "gefallen"),
"außer Dienst": ("a. D.", "außer Dienst"),
}
def zustand_text(status):
kurz, lang = ZUSTAND.get(status, ("", status or "aktiv"))
return f"{kurz} · {lang}" if kurz else lang
def charakter_name(c):
name = " ".join(t for t in (c.get("vorname", ""), c.get("nachname", "")) if t)
if c.get("callsign"):
return f'{c["callsign"]} · {c.get("nachname") or name}' if name else c["callsign"]
return name or c.get("aktennummer") or "Ohne Namen"
def fehlertext(fehler):
if isinstance(fehler, konto.ServerFehler):
return fehler.meldung
return f"Unerwarteter Fehler: {fehler}"
def dialog_zentrieren(fenster, eltern):
dunkle_titelleiste(fenster)
fenster.update_idletasks()
oben = eltern.winfo_toplevel()
x = oben.winfo_rootx() + (oben.winfo_width() - fenster.winfo_width()) // 2
y = oben.winfo_rooty() + (oben.winfo_height() - fenster.winfo_height()) // 3
fenster.geometry(f"+{max(x, 0)}+{max(y, 0)}")
# -- Abgleich ----------------------------------------------------------------------
class AbgleichSteuerung:
"""Stoesst den Abgleich an: nach dem Anmelden, kurz nach Aenderungen und regelmaessig."""
NACH_AENDERUNG_MS = 4000
TAKT_MS = 5 * 60 * 1000
def __init__(self, widget, hintergrund, akte_seite, protokollieren, bei_abmeldung):
self.widget = widget
self.hintergrund = hintergrund
self.akte_seite = akte_seite
self.protokollieren = protokollieren
self.bei_abmeldung = bei_abmeldung
self.beobachter = [akte_seite.abgleich_zustand]
self._job = None
self._laeuft = False
self._erneut = False
akte_seite.bei_gespeichert = lambda: self.anstossen(self.NACH_AENDERUNG_MS)
self.melden()
widget.after(1500, self._takt)
def melden(self, text=None, art="aus"):
if text is None:
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)
def anstossen(self, verzoegerung_ms=0):
if not konto.angemeldet():
self.melden()
return
if self._job is not None:
self.widget.after_cancel(self._job)
self._job = self.widget.after(verzoegerung_ms, self._starten)
def _starten(self):
self._job = None
if self._laeuft:
self._erneut = True
return
self._laeuft = True
self.akte_seite.speichern_sofort()
self.melden("Abgleich läuft …", "laeuft")
self.hintergrund.starten(abgleich.abgleichen, self._fertig, self._fehler)
def _nachlauf(self):
self._laeuft = False
if self._erneut:
self._erneut = False
self.anstossen(500)
def _fertig(self, ergebnis):
if ergebnis is not None:
self.akte_seite.nach_abgleich(ergebnis["geaendert"])
text = f"Mit dem Server abgeglichen · {time.strftime('%H:%M')}"
if ergebnis["konflikte"]:
text += (f" · {ergebnis['konflikte']} Konflikt(e): die Serverfassung liegt als "
"konflikt-Datei im Aktenordner")
self.melden(text, "offline" if ergebnis["konflikte"] else "ok")
self._nachlauf()
def _fehler(self, fehler):
if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet":
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")
else:
self.protokollieren(type(fehler), fehler, fehler.__traceback__)
self.melden(f"Abgleich gescheitert: {fehlertext(fehler)}", "fehler")
self._nachlauf()
def _takt(self):
if konto.angemeldet():
self.anstossen()
try:
self.widget.after(self.TAKT_MS, self._takt)
except tk.TclError:
pass
# -- 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
self.bei_anmeldung = bei_anmeldung
self._knoepfe = []
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=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.meldung_var = tk.StringVar()
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, 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))
verweis.bind("<Button-1>", lambda e, z=ziel: webbrowser.open(z))
@staticmethod
def _feld(eltern, zeile, beschriftung, verdeckt=False):
ttk.Label(eltern, text=beschriftung).grid(row=zeile, column=0, sticky="w", pady=5, padx=(0, 12))
var = tk.StringVar()
eingabe = ttk.Entry(eltern, textvariable=var, width=34, show="•" if verdeckt else "")
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="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=3, column=1, sticky="e", pady=(10, 0))
self._knoepfe.append(knopf)
for eingabe in (erstes, pw):
eingabe.bind("<Return>", lambda e: self.anmelden())
def _zeigen(self, text, art="info"):
farben = {"info": FG, "ok": OLIVE_HI, "fehler": RED, "warnung": AMBER}
self.meldung_var.set(text)
self.meldung.configure(foreground=farben.get(art, FG))
def _beschaeftigt(self, ja):
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:
self._zeigen("Bitte Benutzername oder E-Mail und Passwort eingeben.", "warnung")
return
self.erneut_knopf.pack_forget()
self._beschaeftigt(True)
self._zeigen("Melde an …")
def fertig(nutzer):
self._beschaeftigt(False)
self.passwort_var.set("")
self._zeigen("")
self.bei_anmeldung(nutzer)
def fehler(f):
self._beschaeftigt(False)
self._zeigen(fehlertext(f), "fehler")
if isinstance(f, konto.ServerFehler) and f.code == "nicht_bestaetigt":
self.erneut_knopf.pack(anchor="w", pady=(8, 0))
self.hintergrund.starten(lambda: konto.anmelden(login, passwort), fertig, fehler)
def bestaetigung_erneut(self):
email = self.login_var.get().strip()
if "@" not in email:
self._zeigen("Trage oben deine E-Mail-Adresse ein, dann schicken wir die Mail erneut.", "warnung")
return
self.hintergrund.starten(lambda: konto.bestaetigung_erneut(email),
lambda antwort: self._zeigen(antwort.get("meldung", "Mail ist unterwegs."), "ok"),
lambda f: self._zeigen(fehlertext(f), "fehler"))
# -- Fremde Akte ansehen ----------------------------------------------------------------
def akte_fenster(eltern, charakter, bild_bytes):
"""Zeigt eine Akte vom Server als Dokument in einem eigenen Fenster."""
fenster = tk.Toplevel(eltern)
fenster.title(f"Akte {charakter.get('aktennummer') or ''} – {charakter_name(charakter)}")
fenster.configure(bg=BG)
fenster.geometry("720x820")
fenster.transient(eltern.winfo_toplevel())
leinwand = tk.Canvas(fenster, bg=BG, highlightthickness=0, bd=0)
leiste = ttk.Scrollbar(fenster, orient="vertical", command=leinwand.yview)
leinwand.configure(yscrollcommand=leiste.set)
leiste.pack(side="right", fill="y")
leinwand.pack(side="left", fill="both", expand=True)
daten = modell.migrieren(dict(charakter.get("daten") or {}))
daten["aktennummer"] = charakter.get("aktennummer") or daten.get("aktennummer", "")
fotos = {}
def foto_fuer(groesse):
if not bild_bytes:
return None
if groesse not in fotos:
with Image.open(io.BytesIO(bild_bytes)) as bild:
fotos[groesse] = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), groesse))
return fotos[groesse]
zeichnen = lambda e=None: akte.dokument_zeichnen(leinwand, daten, foto_fuer) # noqa: E731
leinwand.bind("<Configure>", zeichnen)
leinwand.bind("<MouseWheel>", lambda e: leinwand.yview_scroll(int(-e.delta / 120), "units"))
fenster.bind("<Escape>", lambda e: fenster.destroy())
dialog_zentrieren(fenster, eltern)
return fenster
# -- Hauptreiter ------------------------------------------------------------------------
def _tabelle(eltern, spalten, hoehe=12):
rahmen = ttk.Frame(eltern)
baum = ttk.Treeview(rahmen, columns=[s for s, _, _ in spalten], show="headings",
selectmode="browse", height=hoehe)
for schluessel, titel, breite in spalten:
baum.heading(schluessel, text=titel, anchor="w")
baum.column(schluessel, width=breite, anchor="w", stretch=True)
leiste = ttk.Scrollbar(rahmen, orient="vertical", command=baum.yview)
baum.configure(yscrollcommand=leiste.set)
baum.pack(side="left", fill="both", expand=True)
leiste.pack(side="right", fill="y")
baum.tag_configure("kia", foreground=RED)
baum.tag_configure("mia", foreground=AMBER)
baum.tag_configure("wia", foreground=AMBER)
baum.tag_configure("ad", foreground=FG_DIM)
baum.tag_configure("eigener", foreground=OLIVE_HI)
return rahmen, baum
def _zustand_tag(status):
return {"gefallen": "kia", "vermisst": "mia", "verwundet": "wia", "außer Dienst": "ad"}.get(status, "")
class SquadSeite(ttk.Frame):
def __init__(self, master, akte_seite, protokollieren):
super().__init__(master)
self.hintergrund = Hintergrund(self)
self.akte_seite = akte_seite
self.protokollieren = protokollieren
self.charaktere = []
self.squads = []
self.einladungen = {"eingang": [], "ausgang": []}
self._bilder = {}
self._zuletzt_geladen = 0.0
self._laedt = False
self.abgleich = AbgleichSteuerung(self, self.hintergrund, akte_seite, protokollieren,
bei_abmeldung=self._abgemeldet)
self.anmeldung = AnmeldeFlaeche(self, self.hintergrund, self._angemeldet)
self.inhalt = ttk.Frame(self)
self._inhalt_aufbauen()
self.abgleich.beobachter.append(self._abgleich_zustand)
self._ansicht()
if konto.angemeldet():
# Pruefen, ob die gespeicherte Anmeldung noch gilt
self.hintergrund.starten(konto.pruefen, lambda nutzer: self._ansicht(),
self._pruefung_gescheitert)
# -- Umschalten -----------------------------------------------------------------
def _ansicht(self):
if konto.angemeldet():
self.anmeldung.pack_forget()
self.inhalt.pack(fill="both", expand=True)
self._kopf_aktualisieren()
else:
self.inhalt.pack_forget()
self.anmeldung.pack(fill="both", expand=True)
def _pruefung_gescheitert(self, fehler):
if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet":
self._abgemeldet()
def _angemeldet(self, nutzer):
self._ansicht()
self.abgleich.anstossen(0)
self.aktualisieren()
def _abgemeldet(self):
self.charaktere, self.squads = [], []
self.einladungen = {"eingang": [], "ausgang": []}
self._ansicht()
self.abgleich.melden()
def abmelden(self):
if not messagebox.askyesno("Abmelden",
"Abmelden? Deine Akten bleiben auf diesem PC und werden "
"nach der nächsten Anmeldung wieder abgeglichen.", parent=self):
return
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)
fenster.title("Konto löschen")
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=380, justify="left", text=(
"Das Konto wird mit allen Charakteren auf dem Server gelöscht. Führt einer "
"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")
passwort = tk.StringVar()
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 or not mit_passwort:
fenster.destroy()
self.konto_loeschen_ausfuehren(wert)
knoepfe = ttk.Frame(f)
knoepfe.grid(row=2, column=0, columnspan=2, sticky="e", pady=(16, 0))
ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right")
ttk.Button(knoepfe, text="Endgültig löschen", command=loeschen).pack(side="right", padx=(0, 8))
fenster.bind("<Escape>", lambda e: fenster.destroy())
dialog_zentrieren(fenster, self)
fenster.grab_set()
if eingabe is not None:
eingabe.focus_set()
def konto_loeschen_ausfuehren(self, passwort, bestaetigen=True):
def arbeit():
konto.aufrufen("konto_loeschen", passwort=passwort)
# Lokale Akten gelten danach als nie abgeglichen - bei einem neuen
# Konto werden sie wieder hochgeladen statt in den Papierkorb geraeumt
for eintrag in modell.alle_akten():
(modell.ordner_von(eintrag["id"]) / abgleich.META).unlink(missing_ok=True)
konto.abmelden()
def fertig(_):
self._abgemeldet()
if bestaetigen:
messagebox.showinfo("Konto gelöscht", "Dein Konto ist gelöscht.", parent=self)
self.hintergrund.starten(arbeit, fertig,
lambda fehler: messagebox.showerror("Konto löschen", fehlertext(fehler), parent=self))
def sichtbar(self):
"""Vom Hauptfenster aufgerufen, wenn der Reiter gewaehlt wird."""
if konto.angemeldet() and time.time() - self._zuletzt_geladen > 20:
self.aktualisieren()
# -- Aufbau -----------------------------------------------------------------------
def _inhalt_aufbauen(self):
kopf = ttk.Frame(self.inhalt)
kopf.pack(fill="x", pady=(8, 6))
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")
# 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")
self.status.pack(side="left", padx=(16, 0))
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)
def _charaktere_aufbauen(self, nb):
seite = ttk.Frame(nb, padding=10)
nb.add(seite, text="Charaktere")
seite.columnconfigure(0, weight=1)
seite.rowconfigure(1, weight=1)
filter_ = ttk.Frame(seite)
filter_.grid(row=0, column=0, columnspan=2, sticky="ew", pady=(0, 8))
self.suche_var = tk.StringVar()
suche = ttk.Entry(filter_, textvariable=self.suche_var, width=24)
suche.pack(side="left")
suche.bind("<Return>", lambda e: self.aktualisieren())
self.fraktion_var = tk.StringVar(value=ALLE_FRAKTIONEN)
fraktion = ttk.Combobox(filter_, textvariable=self.fraktion_var, state="readonly", width=28,
values=[ALLE_FRAKTIONEN] + vorlagen.fraktionsnamen())
fraktion.pack(side="left", padx=8)
fraktion.bind("<<ComboboxSelected>>", lambda e: self.aktualisieren())
fraktion.bind("<MouseWheel>", lambda e: "break")
ttk.Button(filter_, text="Suchen", command=self.aktualisieren).pack(side="left")
rahmen, self.liste = _tabelle(seite, [("name", "Charakter", 170), ("rang", "Dienstgrad", 150),
("zustand", "Zustand", 90), ("squad", "Squad", 110),
("spieler", "Spieler", 90)])
rahmen.grid(row=1, column=0, sticky="nsew")
self.liste.bind("<<TreeviewSelect>>", lambda e: self._charakter_gewaehlt())
self.liste.bind("<Double-1>", lambda e: self.akte_ansehen())
detail = ttk.Frame(seite, width=240)
detail.grid(row=1, column=1, sticky="nsew", padx=(12, 0))
detail.grid_propagate(False)
self.bild = tk.Label(detail, bg=PANEL, fg=FG_DIM, text="kein\nPorträt", font=FONT_UI,
width=20, height=10)
self.bild.pack(anchor="w")
self.detail_titel = ttk.Label(detail, text="", font=("Segoe UI Semibold", 13), wraplength=230)
self.detail_titel.pack(anchor="w", pady=(8, 2))
self.detail_text = ttk.Label(detail, text="Wähle links einen Charakter.", style="Dim.TLabel",
wraplength=230, justify="left")
self.detail_text.pack(anchor="w")
self.knopf_ansehen = ttk.Button(detail, text="Akte ansehen", command=self.akte_ansehen)
self.knopf_ansehen.pack(anchor="w", fill="x", pady=(10, 4))
self.knopf_einladen = ttk.Button(detail, text="In mein Squad einladen", style="Accent.TButton",
command=self.einladen)
self.knopf_einladen.pack(anchor="w", fill="x")
self.einladen_hinweis = ttk.Label(detail, text="", style="Dim.TLabel", wraplength=230)
self.einladen_hinweis.pack(anchor="w", pady=(4, 0))
self._detail_leeren()
def _squads_aufbauen(self, nb):
seite = ttk.Frame(nb, padding=10)
nb.add(seite, text="Squads")
seite.columnconfigure(0, weight=2)
seite.columnconfigure(1, weight=3)
seite.rowconfigure(1, weight=1)
ttk.Button(seite, text="Squad gründen …", style="Accent.TButton",
command=self.squad_gruenden).grid(row=0, column=0, sticky="w", pady=(0, 8))
rahmen, self.squad_liste = _tabelle(seite, [("name", "Squad", 150), ("fuehrer", "Führer", 120),
("staerke", "Stärke", 55)])
rahmen.grid(row=1, column=0, sticky="nsew")
self.squad_liste.bind("<<TreeviewSelect>>", lambda e: self._squad_gewaehlt())
rechts = ttk.Frame(seite)
rechts.grid(row=1, column=1, sticky="nsew", padx=(12, 0))
rechts.rowconfigure(2, weight=1)
rechts.columnconfigure(0, weight=1)
self.squad_titel = ttk.Label(rechts, text="Wähle ein Squad.", font=("Segoe UI Semibold", 13))
self.squad_titel.grid(row=0, column=0, sticky="w")
self.squad_beschreibung = ttk.Label(rechts, text="", style="Dim.TLabel", wraplength=420, justify="left")
self.squad_beschreibung.grid(row=1, column=0, sticky="w", pady=(2, 8))
rahmen, self.mitglieder = _tabelle(rechts, [("name", "Mitglied", 150), ("rang", "Dienstgrad", 140),
("zustand", "Zustand", 80), ("spieler", "Spieler", 80)], 8)
rahmen.grid(row=2, column=0, sticky="nsew")
self.mitglieder.bind("<<TreeviewSelect>>", lambda e: self._squad_knoepfe())
knoepfe = ttk.Frame(rechts)
knoepfe.grid(row=3, column=0, sticky="w", pady=(8, 0))
self.knopf_entfernen = ttk.Button(knoepfe, text="Entfernen", command=self.mitglied_entfernen)
self.knopf_uebergeben = ttk.Button(knoepfe, text="Führung übergeben", command=self.fuehrung_uebergeben)
self.knopf_verlassen = ttk.Button(knoepfe, text="Squad verlassen", command=self.squad_verlassen)
self.knopf_aufloesen = ttk.Button(knoepfe, text="Squad auflösen", command=self.squad_aufloesen)
for knopf in (self.knopf_entfernen, self.knopf_uebergeben, self.knopf_verlassen, self.knopf_aufloesen):
knopf.pack(side="left", padx=(0, 6))
self._squad_knoepfe()
def _einladungen_aufbauen(self, nb):
seite = ttk.Frame(nb, padding=10)
nb.add(seite, text="Einladungen")
self.einladungen_seite = seite
seite.columnconfigure(0, weight=1)
seite.rowconfigure(1, weight=1)
seite.rowconfigure(4, weight=1)
ttk.Label(seite, text="ERHALTEN", style="Dim.TLabel").grid(row=0, column=0, sticky="w")
rahmen, self.eingang = _tabelle(seite, [("squad", "Squad", 170), ("fuer", "Für deinen Charakter", 190),
("von", "Eingeladen von", 190)], 6)
rahmen.grid(row=1, column=0, sticky="nsew")
knoepfe = ttk.Frame(seite)
knoepfe.grid(row=2, column=0, sticky="w", pady=(6, 14))
ttk.Button(knoepfe, text="Annehmen", style="Accent.TButton",
command=lambda: self.einladung_beantworten(True)).pack(side="left", padx=(0, 6))
ttk.Button(knoepfe, text="Ablehnen", command=lambda: self.einladung_beantworten(False)).pack(side="left")
ttk.Label(seite, text="VERSCHICKT", style="Dim.TLabel").grid(row=3, column=0, sticky="w")
rahmen, self.ausgang = _tabelle(seite, [("squad", "Squad", 170), ("charakter", "Eingeladen", 190),
("spieler", "Spieler", 190)], 5)
rahmen.grid(row=4, column=0, sticky="nsew")
ttk.Button(seite, text="Zurückziehen", command=self.einladung_zurueckziehen).grid(
row=5, column=0, sticky="w", pady=(6, 0))
# -- Laden ------------------------------------------------------------------------
def _abgleich_zustand(self, text, art):
if not self._laedt:
self.status_var.set(text)
def aktualisieren(self):
if not konto.angemeldet() or self._laedt:
return
self._laedt = True
self.status_var.set("Lädt …")
suche = self.suche_var.get().strip()
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"))
self.hintergrund.starten(arbeit, self._geladen, self._laden_gescheitert)
def _laden_gescheitert(self, fehler):
self._laedt = False
if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet":
self._abgemeldet()
return
self.status_var.set(fehlertext(fehler))
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 · "
f"Stand {time.strftime('%H:%M')}")
self._liste_fuellen()
self._squads_fuellen()
self._einladungen_fuellen()
def _ersetzen(self, baum, zeilen):
auswahl = baum.selection()
baum.delete(*baum.get_children())
for iid, werte, tags in zeilen:
baum.insert("", "end", iid=iid, values=werte, tags=tags)
if auswahl and baum.exists(auswahl[0]):
baum.selection_set(auswahl[0])
def _liste_fuellen(self):
zeilen = []
for c in self.charaktere:
tags = tuple(t for t in (_zustand_tag(c["status"]), "eigener" if c["eigener"] else "") if t)
zeilen.append((str(c["id"]), (charakter_name(c), c["rang"], zustand_text(c["status"]),
(c.get("squad") or {}).get("name", "—"), c["spieler"]), tags))
self._ersetzen(self.liste, zeilen)
self._charakter_gewaehlt()
def _squads_fuellen(self):
zeilen = []
for s in self.squads:
fuehrer = next((m for m in s["mitglieder"] if m["id"] == s["fuehrer_id"]), None)
zeilen.append((str(s["id"]), (s["name"], charakter_name(fuehrer) if fuehrer else "—",
len(s["mitglieder"])), ()))
self._ersetzen(self.squad_liste, zeilen)
self._squad_gewaehlt()
def _einladungen_fuellen(self):
self._ersetzen(self.eingang, [
(str(e["id"]), ((e.get("squad") or {}).get("name", "?"), charakter_name(e.get("charakter") or {}),
charakter_name(e.get("von") or {}) + f" ({(e.get('von') or {}).get('spieler', '?')})"), ())
for e in self.einladungen["eingang"]])
self._ersetzen(self.ausgang, [
(str(e["id"]), ((e.get("squad") or {}).get("name", "?"), charakter_name(e.get("charakter") or {}),
(e.get("charakter") or {}).get("spieler", "?")), ())
for e in self.einladungen["ausgang"]])
anzahl = len(self.einladungen["eingang"])
self.nb.tab(self.einladungen_seite, text=f"Einladungen ({anzahl})" if anzahl else "Einladungen")
# -- Charaktere -------------------------------------------------------------------
def _gewaehlter(self):
auswahl = self.liste.selection()
return next((c for c in self.charaktere if str(c["id"]) == auswahl[0]), None) if auswahl else None
def _eigene_ids(self):
return {c["id"] for c in self.charaktere if c["eigener"]}
def _meine_gefuehrten_squads(self):
eigene = self._eigene_ids()
return [s for s in self.squads if s["fuehrer_id"] in eigene]
def _detail_leeren(self):
self.bild.configure(image="", text="kein\nPorträt", width=20, height=10)
self.detail_titel.configure(text="")
self.detail_text.configure(text="Wähle links einen Charakter.")
self.knopf_ansehen.configure(state="disabled")
self.knopf_einladen.configure(state="disabled")
self.einladen_hinweis.configure(text="")
def _charakter_gewaehlt(self):
c = self._gewaehlter()
if c is None:
self._detail_leeren()
return
self.detail_titel.configure(text=c["callsign"] or charakter_name(c))
zeilen = [
" ".join(t for t in (c["rang"], c["vorname"], c["nachname"]) if t),
" · ".join(t for t in (c["fraktion"], c["teilstreitkraft"]) if t),
c["verwendung"],
f"Zustand: {zustand_text(c['status'])}",
f"Squad: {(c.get('squad') or {}).get('name', '—')}",
f"Spieler: {c['spieler']}" + (" (du)" if c["eigener"] else ""),
c.get("aktennummer") or "",
]
self.detail_text.configure(text="\n".join(z for z in zeilen if z))
self.knopf_ansehen.configure(state="normal")
gefuehrt = self._meine_gefuehrten_squads()
hinweis = ""
if c.get("squad"):
hinweis = "Ist schon in einem Squad."
elif not gefuehrt:
hinweis = "Zum Einladen brauchst du ein Squad, das einer deiner Charaktere führt."
self.knopf_einladen.configure(state="disabled" if hinweis else "normal")
self.einladen_hinweis.configure(text=hinweis)
self._bild_zeigen(c)
def _bild_zeigen(self, c):
if not c["portraet"]:
self.bild.configure(image="", text="kein\nPorträt", width=20, height=10)
return
schluessel = (c["id"], c.get("portraet_kennung"))
if schluessel in self._bilder:
foto = self._bilder[schluessel][1]
self.bild.configure(image=foto, text="", width=foto.width(), height=foto.height())
return
self.bild.configure(image="", text="lädt …", width=20, height=10)
def fertig(daten):
if not daten:
return
with Image.open(io.BytesIO(daten)) as bild:
foto = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), (150, 190)))
self._bilder[schluessel] = (daten, foto)
aktuell = self._gewaehlter()
if aktuell is not None and aktuell["id"] == c["id"]:
self.bild.configure(image=foto, text="", width=foto.width(), height=foto.height())
self.hintergrund.starten(lambda: konto.bild(c["id"]), fertig, lambda f: None)
def akte_ansehen(self):
c = self._gewaehlter()
if c is None:
return
def arbeit():
voll = konto.aufrufen("charakter_ansehen", id=c["id"])["charakter"]
bild = konto.bild(c["id"]) if voll.get("portraet") else None
return voll, bild
self.hintergrund.starten(arbeit, lambda erg: akte_fenster(self, erg[0], erg[1]),
lambda f: messagebox.showerror("Akte", fehlertext(f), parent=self))
def einladen(self):
c = self._gewaehlter()
gefuehrt = self._meine_gefuehrten_squads()
if c is None or not gefuehrt:
return
if len(gefuehrt) == 1:
self._einladen_in(gefuehrt[0], c)
return
menue = tk.Menu(self, tearoff=False)
for squad in gefuehrt:
menue.add_command(label=squad["name"], command=lambda s=squad: self._einladen_in(s, c))
knopf = self.knopf_einladen
menue.tk_popup(knopf.winfo_rootx(), knopf.winfo_rooty() + knopf.winfo_height())
def _einladen_in(self, squad, c):
self._aktion(lambda: konto.aufrufen("squad_einladen", squad_id=squad["id"], charakter_id=c["id"]),
f"{charakter_name(c)} ist zu {squad['name']} eingeladen. Der Spieler muss annehmen.")
# -- Squads -----------------------------------------------------------------------
def _gewaehltes_squad(self):
auswahl = self.squad_liste.selection()
return next((s for s in self.squads if str(s["id"]) == auswahl[0]), None) if auswahl else None
def _squad_gewaehlt(self):
s = self._gewaehltes_squad()
if s is None:
self.squad_titel.configure(text="Wähle ein Squad." if self.squads else "Noch keine Squads.")
self.squad_beschreibung.configure(text="")
self._ersetzen(self.mitglieder, [])
else:
self.squad_titel.configure(text=s["name"])
self.squad_beschreibung.configure(text=s.get("beschreibung") or "")
# Der Fuehrer steht immer oben, die anderen in Reihenfolge des Beitritts
mitglieder = sorted(s["mitglieder"], key=lambda m: m["id"] != s["fuehrer_id"])
self._ersetzen(self.mitglieder, [
(str(m["id"]), (("★ " if m["id"] == s["fuehrer_id"] else "") + charakter_name(m), m["rang"],
zustand_text(m["status"]), m["spieler"]),
tuple(t for t in (_zustand_tag(m["status"]), "eigener" if m["eigener"] else "") if t))
for m in mitglieder])
self._squad_knoepfe()
def _gewaehltes_mitglied(self, squad):
auswahl = self.mitglieder.selection()
if squad is None or not auswahl:
return None
return next((m for m in squad["mitglieder"] if str(m["id"]) == auswahl[0]), None)
def _squad_knoepfe(self):
s = self._gewaehltes_squad()
eigene = self._eigene_ids()
fuehre = s is not None and s["fuehrer_id"] in eigene
mitglied = self._gewaehltes_mitglied(s)
fremdes_mitglied = mitglied is not None and mitglied["id"] != s["fuehrer_id"]
mein_mitglied = s is not None and any(m["id"] in eigene and m["id"] != s["fuehrer_id"]
for m in s["mitglieder"])
self.knopf_entfernen.configure(state="normal" if fuehre and fremdes_mitglied else "disabled")
self.knopf_uebergeben.configure(state="normal" if fuehre and fremdes_mitglied else "disabled")
self.knopf_aufloesen.configure(state="normal" if fuehre else "disabled")
self.knopf_verlassen.configure(state="normal" if mein_mitglied or (fuehre and len(s["mitglieder"]) == 1)
else "disabled")
def squad_gruenden(self):
frei = [c for c in self.charaktere if c["eigener"] and not c.get("squad")]
if not frei:
messagebox.showinfo("Squad gründen",
"Du brauchst einen eigenen Charakter ohne Squad. Neue Akten erscheinen "
"hier, sobald sie mit dem Server abgeglichen sind.", parent=self)
return
fenster = tk.Toplevel(self)
fenster.title("Squad gründen")
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, text="Name des Squads").grid(row=0, column=0, sticky="w", pady=5, padx=(0, 12))
name_var = tk.StringVar()
name = ttk.Entry(f, textvariable=name_var, width=36)
name.grid(row=0, column=1, sticky="ew", pady=5)
ttk.Label(f, text="Geführt von").grid(row=1, column=0, sticky="w", pady=5, padx=(0, 12))
namen = [charakter_name(c) for c in frei]
fuehrer_var = tk.StringVar(value=namen[0])
ttk.Combobox(f, textvariable=fuehrer_var, values=namen, state="readonly", width=34).grid(
row=1, column=1, sticky="ew", pady=5)
ttk.Label(f, text="Beschreibung").grid(row=2, column=0, sticky="nw", pady=5, padx=(0, 12))
beschreibung = tk.Text(f, width=36, height=4, **akte.TEXT_STIL)
beschreibung.grid(row=2, column=1, sticky="ew", pady=5)
def gruenden():
c = frei[namen.index(fuehrer_var.get())]
text = beschreibung.get("1.0", "end-1c").strip()
wert = name_var.get().strip()
fenster.destroy()
self._aktion(lambda: konto.aufrufen("squad_gruenden", charakter_id=c["id"], name=wert,
beschreibung=text),
f"Squad {wert} gegründet.")
knoepfe = ttk.Frame(f)
knoepfe.grid(row=3, column=0, columnspan=2, sticky="e", pady=(12, 0))
ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right")
ttk.Button(knoepfe, text="Gründen", style="Accent.TButton", command=gruenden).pack(side="right", padx=(0, 8))
fenster.bind("<Escape>", lambda e: fenster.destroy())
dialog_zentrieren(fenster, self)
fenster.grab_set()
name.focus_set()
def mitglied_entfernen(self):
s = self._gewaehltes_squad()
m = self._gewaehltes_mitglied(s)
if m and messagebox.askyesno("Entfernen", f"{charakter_name(m)} aus {s['name']} entfernen?", parent=self):
self._aktion(lambda: konto.aufrufen("squad_entfernen", squad_id=s["id"], charakter_id=m["id"]),
f"{charakter_name(m)} wurde entfernt.")
def fuehrung_uebergeben(self):
s = self._gewaehltes_squad()
m = self._gewaehltes_mitglied(s)
if m and messagebox.askyesno("Führung übergeben",
f"Die Führung von {s['name']} an {charakter_name(m)} übergeben?", parent=self):
self._aktion(lambda: konto.aufrufen("squad_fuehrung_uebergeben", squad_id=s["id"], charakter_id=m["id"]),
f"{charakter_name(m)} führt jetzt {s['name']}.")
def squad_verlassen(self):
s = self._gewaehltes_squad()
if s is None:
return
eigene = [m for m in s["mitglieder"] if m["eigener"]]
# Wer allein fuehrt, verlaesst das Squad damit auch - es wird aufgeloest
kandidaten = [m for m in eigene if m["id"] != s["fuehrer_id"]] or eigene
if not kandidaten:
return
m = kandidaten[0]
if messagebox.askyesno("Squad verlassen", f"{charakter_name(m)} verlässt {s['name']}?", parent=self):
self._aktion(lambda: konto.aufrufen("squad_verlassen", charakter_id=m["id"]),
f"{charakter_name(m)} hat {s['name']} verlassen.")
def squad_aufloesen(self):
s = self._gewaehltes_squad()
if s and messagebox.askyesno("Squad auflösen",
f"{s['name']} auflösen? Alle Mitglieder sind danach ohne Squad.", parent=self):
self._aktion(lambda: konto.aufrufen("squad_aufloesen", squad_id=s["id"]), f"{s['name']} wurde aufgelöst.")
# -- Einladungen ------------------------------------------------------------------
def einladung_beantworten(self, annehmen):
auswahl = self.eingang.selection()
if not auswahl:
return
e = next((x for x in self.einladungen["eingang"] if str(x["id"]) == auswahl[0]), None)
if e is None:
return
squad = (e.get("squad") or {}).get("name", "das Squad")
self._aktion(lambda: konto.aufrufen("einladung_beantworten", einladung_id=e["id"], annehmen=annehmen),
f"Willkommen in {squad}." if annehmen else "Einladung abgelehnt.")
def einladung_zurueckziehen(self):
auswahl = self.ausgang.selection()
if auswahl:
self._aktion(lambda: konto.aufrufen("einladung_zurueckziehen", einladung_id=int(auswahl[0])),
"Einladung zurückgezogen.")
# -- Gemeinsam --------------------------------------------------------------------
def _aktion(self, arbeit, erfolg):
self.status_var.set("Einen Moment …")
def fertig(_):
self.status_var.set(erfolg)
self._laedt = False
self.aktualisieren()
def fehler(f):
if isinstance(f, konto.ServerFehler) and f.code == "nicht_angemeldet":
self._abgemeldet()
return
self.status_var.set("")
messagebox.showerror("Squad", fehlertext(f), parent=self)
self.aktualisieren()
self.hintergrund.starten(arbeit, fertig, fehler)