"""Bruecke zwischen Oberflaeche (pywebview) und Backend.
|
|
Jede oeffentliche Methode ist aus dem Frontend als
|
`window.pywebview.api.<methode>(...)` erreichbar und liefert JSON-taugliche Werte.
|
Fehler werden nicht geworfen, sondern als `{ok: false, meldung: ...}` gemeldet —
|
ein Ausnahmefehler ueber die Bruecke kaeme in der Oberflaeche nur als
|
unverstaendlicher Text an.
|
"""
|
|
from __future__ import annotations
|
|
import subprocess
|
import tempfile
|
from dataclasses import asdict
|
from pathlib import Path
|
from typing import Any
|
|
from . import bibliothek, konfiguration
|
from .werkzeuge import Werkzeugordner, Zustand
|
|
# Installationsprogramme kommen nicht zwischen die eigenstaendigen Werkzeuge —
|
# sie werden einmal ausgefuehrt und sind danach entbehrlich.
|
UNTERORDNER_INSTALLER = "Installationsprogramme"
|
|
# Vorerst melden nur unsere eigenen Werkzeuge Updates. Fremdprogramme kuemmern
|
# sich teils selbst darum, und wo nicht, fehlt uns ein verlaesslicher Weg, ihre
|
# installierte Fassung zu erkennen. Bewusst eng gehalten, leicht zu weiten.
|
EINSTUFUNG_MIT_UPDATEPRUEFUNG = "intern"
|
|
|
class Api:
|
def __init__(self) -> None:
|
self._einstellungen = konfiguration.laden()
|
self._ordner = Werkzeugordner(self._einstellungen.werkzeugOrdner)
|
self._ordner.altlasten_aufraeumen()
|
|
# --- Einstellungen ---
|
|
def einstellungen(self) -> dict[str, Any]:
|
return {
|
"einstellungen": asdict(self._einstellungen),
|
"vorgaben": {
|
"serverAdresse": konfiguration.STANDARD_SERVER,
|
"werkzeugOrdner": konfiguration.STANDARD_WERKZEUG_ORDNER,
|
},
|
}
|
|
def einstellungen_speichern(self, serverAdresse: str, werkzeugOrdner: str) -> dict[str, Any]:
|
self._einstellungen = konfiguration.speichern(
|
konfiguration.Einstellungen(serverAdresse=serverAdresse, werkzeugOrdner=werkzeugOrdner)
|
)
|
self._ordner = Werkzeugordner(self._einstellungen.werkzeugOrdner)
|
return {"ok": True, **self.einstellungen()}
|
|
# --- Katalog ---
|
|
def katalog(self) -> dict[str, Any]:
|
"""Katalog der Bibliothek, angereichert um den Befund auf diesem Rechner."""
|
try:
|
eintraege = bibliothek.katalog(self._einstellungen.serverAdresse)
|
except bibliothek.BibliothekNichtErreichbar as fehler:
|
return {"ok": False, "meldung": str(fehler), "eintraege": []}
|
|
angereichert = []
|
for eintrag in eintraege:
|
eigenstaendig = eintrag.get("programmart") == "eigenstaendig"
|
befund = (
|
self._ordner.befund(int(eintrag["id"]), str(eintrag.get("version") or ""))
|
if eigenstaendig
|
else None
|
)
|
angereichert.append(
|
{
|
**eintrag,
|
"lokal": asdict(befund) if befund else None,
|
"ueberwacht": eigenstaendig
|
and eintrag.get("einstufung") == EINSTUFUNG_MIT_UPDATEPRUEFUNG,
|
}
|
)
|
return {"ok": True, "eintraege": angereichert, "ordner": str(self._ordner.ordner)}
|
|
def veraltete(self) -> list[dict[str, str]]:
|
"""Kurzfassung fuer die Meldung beim Start: was ist ueberwacht und nicht aktuell."""
|
stand = self.katalog()
|
if not stand["ok"]:
|
return []
|
return [
|
{"name": eintrag["name"], "zustand": eintrag["lokal"]["zustand"]}
|
for eintrag in stand["eintraege"]
|
if eintrag["ueberwacht"]
|
and eintrag["lokal"]
|
and eintrag["lokal"]["zustand"] in (Zustand.VERALTET.value, Zustand.FREMD.value)
|
]
|
|
# --- Holen ---
|
|
def herunterladen(self, software_id: int, dateiname: str, version: str, programmart: str) -> dict[str, Any]:
|
"""Holt eine Datei und legt sie am passenden Ort ab.
|
|
Eigenstaendige Programme kommen in den Werkzeug-Ordner und werden im Stand
|
vermerkt; Installationsprogramme daneben in einen eigenen Unterordner, ohne
|
Vermerk — was installiert ist, sagt der Ordner ohnehin nicht.
|
"""
|
if not dateiname:
|
return {"ok": False, "meldung": "Für diesen Eintrag liegt keine Datei bereit."}
|
|
eigenstaendig = programmart == "eigenstaendig"
|
with tempfile.TemporaryDirectory(prefix="bibliothek-") as zwischenlager:
|
zwischenziel = Path(zwischenlager) / dateiname
|
try:
|
bibliothek.datei_holen(self._einstellungen.serverAdresse, int(software_id), zwischenziel)
|
except bibliothek.BibliothekNichtErreichbar as fehler:
|
return {"ok": False, "meldung": str(fehler)}
|
|
try:
|
if eigenstaendig:
|
abgelegt = self._ordner.ablegen(int(software_id), zwischenziel, dateiname, version)
|
else:
|
ziel = self._ordner.ordner / UNTERORDNER_INSTALLER / dateiname
|
ziel.parent.mkdir(parents=True, exist_ok=True)
|
ziel.unlink(missing_ok=True)
|
zwischenziel.replace(ziel)
|
abgelegt = ziel
|
except OSError as fehler:
|
return {"ok": False, "meldung": f"Ablegen fehlgeschlagen: {fehler}"}
|
|
return {
|
"ok": True,
|
"pfad": str(abgelegt),
|
"meldung": (
|
f"Abgelegt unter {abgelegt}. Lief das Programm gerade, wirkt die neue "
|
"Fassung nach dem nächsten Start."
|
if eigenstaendig
|
else f"Abgelegt unter {abgelegt}. Nach der Installation kann die Datei gelöscht werden."
|
),
|
}
|
|
# --- Windows-Handreichungen ---
|
|
def ordner_oeffnen(self, unterordner: str = "") -> dict[str, Any]:
|
ziel = self._ordner.ordner / unterordner if unterordner else self._ordner.ordner
|
ziel.mkdir(parents=True, exist_ok=True)
|
subprocess.Popen(["explorer", str(ziel)]) # noqa: S603,S607 - fester Befehl
|
return {"ok": True}
|
|
def verknuepfung_anlegen(self, pfad: str, name: str) -> dict[str, Any]:
|
"""Legt eine Verknuepfung auf dem Desktop an — das kann kein Browser."""
|
ziel = Path(pfad)
|
if not ziel.exists():
|
return {"ok": False, "meldung": "Die Datei liegt nicht (mehr) an diesem Ort."}
|
skript = (
|
"$verknuepfung = (New-Object -ComObject WScript.Shell)."
|
"CreateShortcut([Environment]::GetFolderPath('Desktop') + '\\' + $env:VERKNUEPFUNG_NAME + '.lnk');"
|
"$verknuepfung.TargetPath = $env:VERKNUEPFUNG_ZIEL;"
|
"$verknuepfung.WorkingDirectory = Split-Path $env:VERKNUEPFUNG_ZIEL;"
|
"$verknuepfung.Save()"
|
)
|
try:
|
subprocess.run( # noqa: S603
|
["powershell", "-NoProfile", "-NonInteractive", "-Command", skript],
|
check=True,
|
capture_output=True,
|
timeout=30,
|
env={**_umgebung(), "VERKNUEPFUNG_ZIEL": str(ziel), "VERKNUEPFUNG_NAME": _dateiname_saeubern(name)},
|
)
|
except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as fehler:
|
return {"ok": False, "meldung": f"Verknüpfung fehlgeschlagen: {fehler}"}
|
return {"ok": True, "meldung": f"Verknüpfung „{name}“ liegt auf dem Desktop."}
|
|
|
def _umgebung() -> dict[str, str]:
|
import os
|
|
return dict(os.environ)
|
|
|
def _dateiname_saeubern(name: str) -> str:
|
verboten = '\\/:*?"<>|'
|
gesaeubert = "".join(zeichen for zeichen in name if zeichen not in verboten).strip()
|
return gesaeubert or "Programm"
|
