Mehrere Akten mit Liste, Formular und Dokumentansicht, Portraet, Statusstempel bei gefallen und vermisst, Vorschlagslisten fuer 22 Fraktionen samt Dienstgraden. Datenmodell in akte_modell.py ohne tkinter, Vorlagen in akte_vorlagen.py. Speichern atomar mit Sicherung, Loeschen ueber einen Papierkorb-Ordner. Neue Abhaengigkeit Pillow. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
234 lines
7.4 KiB
Python
234 lines
7.4 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):
|
|
"""Schreibt die Akte atomar und haelt die vorige Fassung als .bak."""
|
|
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"
|