squad-manager/akte_modell.py
danny 0c7aae5b93 Abgleich der Akten mit dem Server (ohne Oberflaeche)
- konto.py: Aufrufe der Schnittstelle, Anmeldung; das Token liegt per
  DPAPI an das Windows-Konto gebunden in konto.json
- abgleich.py: gleicht lokale Akten und Server ab. server.json neben
  jeder Akte haelt den Stand des letzten Abgleichs (Pruefwert des Inhalts
  statt Zeitstempel, der nur sekundengenau ist). Konflikte sichern die
  Serverfassung als konflikt-<Zeit>.json; auf dem Server geloeschte Akten
  wandern lokal in den Papierkorb
- hintergrund.py: Netzwerkarbeit im Thread, Ergebnis im tkinter-Hauptthread
- akte_modell.speichern(zeit_setzen=False) fuer uebernommene Serverdaten
- Server liefert portraet_kennung, damit ein zweiter Rechner neue Bilder erkennt
- Tests: werkzeuge/abgleich_test.py mit zwei simulierten Rechnern (34
  Faelle); der Testserver nutzt php-cgi statt "php -S", das unter Windows
  nach vielen Verbindungen haengen bleibt

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 19:50:57 +02:00

241 lines
7.6 KiB
Python

"""
Datenmodell und Speicherung der Personalakten.
Bewusst ohne tkinter: Laden, Speichern und spaetere Umbauten des Formats
lassen sich so ohne Oberflaeche pruefen.
Ablage je Akte:
%APPDATA%\\SquadManager\\akten\\<id>\\akte.json
%APPDATA%\\SquadManager\\akten\\<id>\\portraet.png
Geschrieben wird atomar - erst in eine Zwischendatei, dann umbenennen -
und die vorherige Fassung bleibt als akte.json.bak liegen. Ein Absturz
mitten im Speichern kann eine Akte damit nicht zerstoeren.
"""
import copy
import datetime
import json
import os
import re
import shutil
import uuid
from pathlib import Path
SCHEMA = 1
AKTEN_ORDNER = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "akten"
PAPIERKORB = AKTEN_ORDNER / "_papierkorb"
DATEI = "akte.json"
PORTRAET = "portraet.png"
PORTRAET_MAX = 512
STATUS = ("aktiv", "verwundet", "vermisst", "gefallen", "außer Dienst")
_VORLAGE = {
"schema": SCHEMA,
"id": "",
"aktennummer": "",
"erstellt": "",
"geaendert": "",
"personalien": {
"vorname": "", "nachname": "", "callsign": "",
"geburtsdatum": "", "herkunft": "",
},
"dienst": {
"fraktion": "", "teilstreitkraft": "",
"einheit": {"verband": "", "bataillon": "", "kompanie": "",
"zug": "", "gruppe": ""},
"rang": "", "verwendung": "", "dienstbeginn": "", "status": "aktiv",
},
"beschreibung": "",
"auszeichnungen": [],
"einsaetze": [],
"vermerke": "",
}
class AktenFehler(Exception):
"""Fehler, die sich dem Nutzer verstaendlich melden lassen."""
def zeitstempel():
return datetime.datetime.now().isoformat(timespec="seconds")
def leere_akte():
akte = copy.deepcopy(_VORLAGE)
akte["id"] = uuid.uuid4().hex
akte["erstellt"] = akte["geaendert"] = zeitstempel()
return akte
def _ergaenzen(daten, vorlage):
"""Fehlende Felder aus der Vorlage nachtragen, vorhandene nie ueberschreiben."""
for schluessel, standard in vorlage.items():
if schluessel not in daten:
daten[schluessel] = copy.deepcopy(standard)
elif isinstance(standard, dict) and isinstance(daten[schluessel], dict):
_ergaenzen(daten[schluessel], standard)
return daten
def migrieren(daten):
"""
Bringt eine gelesene Akte auf den aktuellen Stand.
Bei neuen Schema-Versionen kommen die Umbauschritte hierher. Unbekannte
Felder bleiben erhalten, damit eine aeltere Programmfassung Daten einer
neueren nicht stillschweigend verliert.
"""
if not isinstance(daten, dict):
raise AktenFehler("Die Datei enthaelt keine Akte.")
return _ergaenzen(daten, _VORLAGE)
def ordner_von(akte_id):
if not re.fullmatch(r"[0-9a-f]{32}", str(akte_id)):
raise AktenFehler(f"Ungueltige Akten-ID: {akte_id!r}")
return AKTEN_ORDNER / akte_id
def _alle_nummern():
nummern = []
for datei in list(AKTEN_ORDNER.glob(f"*/{DATEI}")) + list(PAPIERKORB.glob(f"*/{DATEI}")):
try:
nummern.append(json.loads(datei.read_text(encoding="utf-8")).get("aktennummer", ""))
except Exception:
continue
return nummern
def naechste_aktennummer(jahr=None):
"""SM-<Jahr>-<laufende Nummer>; auch Akten im Papierkorb zaehlen mit."""
jahr = jahr or datetime.date.today().year
hoechste = 0
for nummer in _alle_nummern():
treffer = re.fullmatch(rf"SM-{jahr}-(\d+)", str(nummer))
if treffer:
hoechste = max(hoechste, int(treffer.group(1)))
return f"SM-{jahr}-{hoechste + 1:04d}"
def speichern(akte, zeit_setzen=True):
"""
Schreibt die Akte atomar und haelt die vorige Fassung als .bak.
zeit_setzen=False nutzt der Abgleich, wenn er Daten vom Server
uebernimmt: Die Aenderungszeit bleibt dann die des Servers, sonst
saehe die Akte beim naechsten Abgleich wie lokal geaendert aus.
"""
if zeit_setzen or not akte.get("geaendert"):
akte["geaendert"] = zeitstempel()
ordner = ordner_von(akte["id"])
ordner.mkdir(parents=True, exist_ok=True)
ziel = ordner / DATEI
zwischen = ordner / (DATEI + ".tmp")
zwischen.write_text(json.dumps(akte, indent=2, ensure_ascii=False),
encoding="utf-8")
if ziel.exists():
shutil.copy2(ziel, ordner / (DATEI + ".bak"))
os.replace(zwischen, ziel)
return akte
def neu_anlegen():
akte = leere_akte()
akte["aktennummer"] = naechste_aktennummer()
return speichern(akte)
def laden(akte_id):
"""Liest eine Akte; ist die Datei beschaedigt, wird die Sicherung versucht."""
ordner = ordner_von(akte_id)
for datei in (ordner / DATEI, ordner / (DATEI + ".bak")):
if not datei.exists():
continue
try:
return migrieren(json.loads(datei.read_text(encoding="utf-8")))
except (ValueError, AktenFehler):
continue
raise AktenFehler(f"Akte {akte_id} ist nicht lesbar.")
def alle_akten():
"""Alle lesbaren Akten, nach Aktennummer sortiert. Defekte werden uebersprungen."""
if not AKTEN_ORDNER.is_dir():
return []
akten = []
for ordner in AKTEN_ORDNER.iterdir():
if not ordner.is_dir() or ordner.name.startswith("_"):
continue
try:
akten.append(laden(ordner.name))
except AktenFehler:
continue
return sorted(akten, key=lambda a: a.get("aktennummer", ""))
def in_papierkorb(akte_id):
"""Verschiebt statt zu loeschen - Wiederherstellen bleibt moeglich."""
quelle = ordner_von(akte_id)
if not quelle.is_dir():
return None
PAPIERKORB.mkdir(parents=True, exist_ok=True)
ziel = PAPIERKORB / f"{akte_id}_{datetime.datetime.now():%Y%m%d-%H%M%S}"
shutil.move(str(quelle), str(ziel))
return ziel
def portraet_pfad(akte_id):
pfad = ordner_von(akte_id) / PORTRAET
return pfad if pfad.is_file() else None
def portraet_setzen(akte_id, quelle):
"""
Uebernimmt ein Bild als Portraet: Kopie, hoechstens 512 Bildpunkte je
Seite, als PNG. Die Akte haengt danach nicht mehr am Original.
"""
from PIL import Image, ImageOps, UnidentifiedImageError
try:
with Image.open(quelle) as bild:
bild = ImageOps.exif_transpose(bild)
bild = bild.convert("RGBA" if bild.mode in ("RGBA", "LA", "P") else "RGB")
bild.thumbnail((PORTRAET_MAX, PORTRAET_MAX))
ordner = ordner_von(akte_id)
ordner.mkdir(parents=True, exist_ok=True)
zwischen = ordner / (PORTRAET + ".tmp")
bild.save(zwischen, "PNG")
os.replace(zwischen, ordner / PORTRAET)
except (UnidentifiedImageError, OSError) as fehler:
raise AktenFehler(f"Das Bild konnte nicht gelesen werden:\n{fehler}") from fehler
return ordner_von(akte_id) / PORTRAET
def portraet_entfernen(akte_id):
pfad = portraet_pfad(akte_id)
if pfad:
pfad.unlink()
def anzeigename(akte):
"""Kurzname fuer Listen: Rang, Name und Callsign, soweit vorhanden."""
p, d = akte.get("personalien", {}), akte.get("dienst", {})
name = " ".join(t for t in (p.get("vorname", ""), p.get("nachname", "")) if t)
teile = [t for t in (d.get("rang", ""), name) if t]
text = " ".join(teile)
if p.get("callsign"):
text = f'{text} „{p["callsign"]}“' if text else f'„{p["callsign"]}“'
return text or "Neue Akte"
def listenname(akte):
"""Knapper Name fuer die schmale Aktenliste: Callsign vor Nachname."""
p = akte.get("personalien", {})
vorname, nachname = p.get("vorname", ""), p.get("nachname", "")
name = f"{nachname}, {vorname}" if nachname and vorname else nachname or vorname
if p.get("callsign"):
return f'{p["callsign"]} · {nachname or vorname}' if name else p["callsign"]
return name or "Neue Akte"