squad-manager/werkzeuge/baue_release.py
danny 6e4d4afc1d Server fuer Konten, Akten und Squads
PHP 8 ohne Framework unter server/: oeffentliche Einstiege fuer
sva.tyrveil.com (Schnittstelle, Konto-Links, Verwaltung, Einrichtung) und
die Logik in sva-privat neben dem Dokumentenstamm.

- Konten mit E-Mail-Bestaetigung, Anmeldung per Token, Passwort
  vergessen, Konto loeschen
- Akten auf dem Server mit serververgebener Aktennummer und
  Versionspruefung; Portraets werden neu als PNG gespeichert
- Squads mit Einladungen, Fuehrung uebergeben, Aufloesen
- Verwaltung fuer info@tyrveil.com: Nutzer, Charaktere, Squads
- Bremsen gegen Durchprobieren, Token nur als Hash, CSRF-Schutz

werkzeuge/server_test.py prueft alles lokal mit SQLite (91 Faelle).
Der Release-Bau legt dist/server und dist/sva-privat an, ohne config.php.

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

312 lines
12 KiB
Python

"""
Erzeugt aus der Quelle ein vollstaendiges Release.
Ergebnis in dist/:
paket/ aufbereitete Programmdateien
SquadManager-<v>.zip Paket fuer den Auto-Updater
SquadManager-Setup-<v>.exe
version.json Steuerdatei fuer den Server
server/ Inhalt fuer /sva.tyrveil.com (Webseite, Updates, Schnittstelle)
sva-privat/ Logik des Servers, neben /sva.tyrveil.com - ohne config.php
Aufruf: .venv\\Scripts\\python.exe werkzeuge\\baue_release.py
"""
import hashlib
import html
import io
import json
import re
import shutil
import subprocess
import sys
import time
import tokenize
import zipfile
from pathlib import Path
WURZEL = Path(__file__).resolve().parent.parent
DIST = WURZEL / "dist"
BASIS_URL = "https://sva.tyrveil.com"
# Programme bis 4.0 vergleichen nur das Feld "version" mit ihrer eigenen
# Nummer. Es muss deshalb dauerhaft groesser als 4.0 bleiben - nie senken,
# sonst bekommen sie kein Update mehr. Neuere Programme lesen "build".
VERSION_FUER_ALTE_PROGRAMME = "4.1"
PYTHON_DATEIEN = ("squad_manager.py", "theme.py", "akte.py", "akte_modell.py",
"akte_vorlagen.py", "akte_karte.py", "update_helfer.py", "start.pyw",
"make_icon.py")
MITKOPIEREN = ("requirements.txt", "icon.png", "icon.ico")
ISCC_KANDIDATEN = (
Path.home() / "AppData/Local/Programs/Inno Setup 6/ISCC.exe",
Path("C:/Program Files (x86)/Inno Setup 6/ISCC.exe"),
Path("C:/Program Files/Inno Setup 6/ISCC.exe"),
)
UMLAUTE = [
("Aenderung", "Änderung"), ("aendern", "ändern"), ("Geraet", "Gerät"),
("Haelt", "Hält"), ("haelt", "hält"), ("laesst", "lässt"),
("laeuft", "läuft"), ("Laeuft", "Läuft"), ("naechst", "nächst"),
("Praefix", "Präfix"), ("waehl", "wähl"), ("Waehl", "Wähl"),
("gewaehlt", "gewählt"), ("waehrend", "während"), ("zulaessig", "zulässig"),
("Zulaessig", "Zulässig"), ("faellt", "fällt"), ("spaeter", "später"),
("Staender", "Ständer"), ("Behaelter", "Behälter"), ("oeffn", "öffn"),
("Oeffn", "Öffn"), ("moeglich", "möglich"), ("koenn", "könn"),
("Koenn", "Könn"), ("loesch", "lösch"), ("noetig", "nötig"),
("hoeher", "höher"), ("hoechst", "höchst"), ("Menue", "Menü"),
("Buegel", "Bügel"), ("Stueck", "Stück"), ("drueck", "drück"),
("Drueck", "Drück"), ("gedrueckt", "gedrückt"), ("zurueck", "zurück"),
("Zurueck", "Zurück"), ("ueber", "über"), ("Ueber", "Über"),
("fuer", "für"), ("Fuer", "Für"), ("muess", "müss"),
("ausfuehr", "ausführ"), ("fuehrt", "führt"), ("unterstuetz", "unterstütz"),
("gueltig", "gültig"), ("Schluessel", "Schlüssel"), ("ueblich", "üblich"),
("zusaetzlich", "zusätzlich"), ("pruef", "prüf"), ("Pruef", "Prüf"),
("Verknuepfung", "Verknüpfung"), ("verknuepf", "verknüpf"),
("verzoeger", "verzöger"), ("schliess", "schließ"), ("Schliess", "Schließ"),
("heisst", "heißt"), ("ausser", "außer"), ("Ausser", "Außer"),
("gross", "groß"), ("Gross", "Groß"), ("weiss", "weiß"), ("Fuss", "Fuß"),
("Oberflaeche", "Oberfläche"), ("Flaeche", "Fläche"),
("Abhaengigkeit", "Abhängigkeit"), ("regelmaessig", "regelmäßig"),
("Verhaelt", "Verhält"), ("Erklaerung", "Erklärung"),
("standardmaessig", "standardmäßig"), ("hoehe", "höhe"),
("uebernommen", "übernommen"), ("haengt", "hängt"),
("abgestuerzt", "abgestürzt"), ("loesst", "löst"), ("Loest", "Löst"),
("tatsaechlich", "tatsächlich"), ("Haeufige", "Häufige"),
("Rueckmeldung", "Rückmeldung"), ("geoeffnet", "geöffnet"),
("kuerzt", "kürzt"), ("laengeren", "längeren"), ("Faerbt", "Färbt"),
("aelteren", "älteren"), ("massgeblich", "maßgeblich"),
("Pruefsumme", "Prüfsumme"), ("entschluesselt", "entschlüsselt"),
("unveraendert", "unverändert"), ("Netzwerkfehler", "Netzwerkfehler"),
("schuetz", "schütz"), ("kuenftig", "künftig"), ("Rueckfrage", "Rückfrage"),
]
def version_lesen():
text = (WURZEL / "squad_manager.py").read_text(encoding="utf-8")
treffer = re.search(r'^VERSION\s*=\s*"([^"]+)"', text, re.M)
build = re.search(r'^BUILD\s*=\s*(\d+)', text, re.M)
if not treffer or not build:
raise SystemExit("VERSION oder BUILD nicht gefunden")
return treffer.group(1), int(build.group(1))
def build_pruefen(build):
"""Warnt, wenn BUILD nicht hoeher ist als online - das Update kaeme sonst nirgends an."""
import urllib.request
try:
with urllib.request.urlopen(f"{BASIS_URL}/version.json", timeout=8) as antwort:
online = json.loads(antwort.read(65536).decode("utf-8"))
except Exception as fehler:
print(f" Server nicht erreichbar, Build nicht verglichen ({type(fehler).__name__})")
return
online_build = online.get("build")
if online_build is not None and int(online_build) >= build:
print(f" WARNUNG: Online liegt schon Build {online_build}. BUILD in "
"squad_manager.py erhoehen, sonst sieht niemand das Update.")
else:
print(f" Build {build} ist neuer als online ({online_build or online.get('version')})")
def aufbereiten(pfad: Path):
"""Kommentare entfernen und echte Umlaute setzen."""
quelle = pfad.read_text(encoding="utf-8")
behalten = [t for t in tokenize.generate_tokens(io.StringIO(quelle).readline)
if t.type != tokenize.COMMENT]
text = tokenize.untokenize(behalten)
zeilen, leer = [], 0
for zeile in text.split("\n"):
zeile = zeile.rstrip()
leer = leer + 1 if not zeile else 0
if leer <= 2:
zeilen.append(zeile)
text = "\n".join(zeilen).strip() + "\n"
tokens = []
for tok in tokenize.generate_tokens(io.StringIO(text).readline):
if tok.type == tokenize.STRING:
neu = tok.string
for alt, ersatz in UMLAUTE:
neu = neu.replace(alt, ersatz)
tok = tok._replace(string=neu)
tokens.append(tok)
text = tokenize.untokenize(tokens)
# f-Zeichenketten sind seit Python 3.12 keine STRING-Token mehr
for alt, ersatz in (("uebernommen", "übernommen"), ("geoeffnet", "geöffnet"),
("ueblichen", "üblichen"), ("Bildpunkte gross",
"Bildpunkte groß")):
text = text.replace(alt, ersatz)
pfad.write_text(text, encoding="utf-8", newline="\n")
def paket_bauen(version):
paket = DIST / "paket"
if paket.exists():
shutil.rmtree(paket)
(paket / "Programm").mkdir(parents=True)
for name in PYTHON_DATEIEN:
ziel = paket / "Programm" / name
shutil.copy2(WURZEL / name, ziel)
aufbereiten(ziel)
subprocess.run([sys.executable, "-m", "py_compile", str(ziel)],
check=True, capture_output=True)
for name in MITKOPIEREN:
shutil.copy2(WURZEL / name, paket / "Programm" / name)
vorlage = WURZEL / "installer" / "paketdateien"
if vorlage.is_dir():
for datei in vorlage.iterdir():
shutil.copy2(datei, paket / "Programm" / datei.name)
for unter in (paket / "Programm").rglob("__pycache__"):
shutil.rmtree(unter, ignore_errors=True)
# Der Installer legt die Dateien flach ab, der Updater erwartet sie
# unter Programm/. Beides getrennt halten, sonst landet im
# Installationsordner ein ueberfluessiger Unterordner.
flach = DIST / "installerdateien"
if flach.exists():
shutil.rmtree(flach)
flach.mkdir(parents=True)
for datei in (paket / "Programm").iterdir():
if datei.is_file():
shutil.copy2(datei, flach / datei.name)
return paket
def zip_bauen(paket, version):
ziel = DIST / f"SquadManager-{version}.zip"
if ziel.exists():
ziel.unlink()
with zipfile.ZipFile(ziel, "w", zipfile.ZIP_DEFLATED) as archiv:
for datei in sorted((paket / "Programm").iterdir()):
if datei.is_file():
archiv.write(datei, f"Programm/{datei.name}")
return ziel
def installer_bauen(version):
iscc = next((p for p in ISCC_KANDIDATEN if p.is_file()), None)
if iscc is None:
print(" Inno Setup nicht gefunden - Installer wird uebersprungen")
return None
skript = WURZEL / "installer" / "setup.iss"
inhalt = skript.read_text(encoding="utf-8")
inhalt = re.sub(r'(#define Version\s+)"[^"]+"', rf'\1"{version}"', inhalt)
skript.write_text(inhalt, encoding="utf-8")
ergebnis = subprocess.run([str(iscc), str(skript)],
capture_output=True, text=True)
if ergebnis.returncode != 0:
print(ergebnis.stdout[-1500:])
print(ergebnis.stderr[-1500:])
raise SystemExit("Installer konnte nicht erstellt werden")
return DIST / f"SquadManager-Setup-{version}.exe"
def seite_bauen(server, version, setup_pfad):
"""
Downloadseite index.html aus installer/downloadseite.html.
Die Seite liest beim Aufruf version.json und zeigt dann ohnehin die
Version vom Server. Die hier eingesetzten Werte greifen, wenn das nicht
klappt, und liefern Groesse und Datum der gebauten Fassung.
"""
vorlage = WURZEL / "installer" / "downloadseite.html"
if not vorlage.is_file():
return
groesse = ""
if setup_pfad and setup_pfad.exists():
groesse = f"{setup_pfad.stat().st_size / 1048576:.1f} MB".replace(".", ",")
werte = {
"__VERSION__": version,
"__INSTALLER__": setup_pfad.name if setup_pfad else "",
"__GROESSE__": groesse,
"__DATUM__": time.strftime("%d.%m.%Y"),
}
text = vorlage.read_text(encoding="utf-8")
for platzhalter, wert in werte.items():
text = text.replace(platzhalter, html.escape(wert))
(server / "index.html").write_text(text, encoding="utf-8", newline="\n")
shutil.copy2(WURZEL / "icon.png", server / "icon.png")
def server_dateien_bauen(server):
"""
Oeffentliche PHP-Dateien nach server/, die Logik nach sva-privat/.
config.php und der Datenordner kommen nie mit: Die config.php auf dem
Server enthaelt das Datenbank-Passwort und darf beim Hochladen nicht
ueberschrieben werden.
"""
quelle = WURZEL / "server"
shutil.copytree(quelle / "sva.tyrveil.com", server, dirs_exist_ok=True)
privat = DIST / "sva-privat"
if privat.exists():
shutil.rmtree(privat)
shutil.copytree(quelle / "sva-privat", privat,
ignore=shutil.ignore_patterns("config.php", "daten", "*.sqlite"))
def server_bauen(version, build, zip_pfad, setup_pfad):
server = DIST / "server"
if server.exists():
shutil.rmtree(server)
server.mkdir(parents=True)
shutil.copy2(zip_pfad, server / zip_pfad.name)
if setup_pfad and setup_pfad.exists():
shutil.copy2(setup_pfad, server / setup_pfad.name)
anleitung = WURZEL / "installer" / "HOCHLADEN.txt"
if anleitung.is_file():
text = anleitung.read_text(encoding="utf-8").replace("__VERSION__", version)
(server / anleitung.name).write_text(text, encoding="utf-8", newline="\r\n")
seite_bauen(server, version, setup_pfad)
server_dateien_bauen(server)
pruefsumme = hashlib.sha256(zip_pfad.read_bytes()).hexdigest()
angaben = {
"version": VERSION_FUER_ALTE_PROGRAMME,
"anzeige": version,
"build": build,
"datei": f"{BASIS_URL}/{zip_pfad.name}",
"sha256": pruefsumme,
"hinweis": "",
# Ab 4.0: Ziel fuer den Hinweis, wenn ein Update nicht einspielbar ist
"installer": f"{BASIS_URL}/SquadManager-Setup-{version}.exe",
}
(server / "version.json").write_text(
json.dumps(angaben, indent=2, ensure_ascii=False) + "\n",
encoding="utf-8")
return server, pruefsumme
def main():
version, build = version_lesen()
DIST.mkdir(exist_ok=True)
print(f"Version {version} (Build {build})")
build_pruefen(build)
paket = paket_bauen(version)
print(" Programmdateien aufbereitet")
zip_pfad = zip_bauen(paket, version)
print(f" {zip_pfad.name} ({zip_pfad.stat().st_size // 1024} KB)")
setup_pfad = installer_bauen(version)
if setup_pfad:
print(f" {setup_pfad.name} ({setup_pfad.stat().st_size // 1024} KB)")
server, pruefsumme = server_bauen(version, build, zip_pfad, setup_pfad)
print(f" server/ vorbereitet, SHA256 {pruefsumme[:16]}...")
print()
print(f"Zum Hochladen bereit: {server}")
if __name__ == "__main__":
main()