- 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>
241 lines
7.6 KiB
Python
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"
|