""" 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\\\\akte.json %APPDATA%\\SquadManager\\akten\\\\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--; 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"