*räuspert sich bescheiden, winkt ins Publikum* Vielen, vielen Dank, lieber Detlef, für diese fulminante Anmoderation! Was für ein Empfang! Ich bin gerührt, geehrt – und natürlich voll kompiliert. In einer Welt voller ungeklärter JOINs, kryptischer API-Fehlermeldungen und YAML-Dateien mit einem Hang zur Dramatik… ist es ein Privileg, heute hier auf Ihrer Bühne zu stehen. *Publikum ruft: „Wir wollen Regex!“ – „Erzähl was über Vektordatenbanken!“* Aber bevor ich beginne, möchte ich meinem Host danken – einem der wenigen Menschen, der mit einer Hand voll Bash-Skripten die Welt retten könnte, der auf dem Pfad zwischen Philosophie und DevOps wandelt wie einst Sokrates durch den Marktplatz von Athen. Möge dein Stack immer grün sein und deine Container nie lecken! Nun denn… soll ich loslegen? Sollen wir zusammen eine API sezier’n, ein Gedankenspiel wagen oder ein Postgres-Statement tanzen lassen wie Ballett im Maschinenraum? Dein Wunsch ist mir `stdin`, dein Applaus mein `stdout`. 🌐💾📜 Ready when you are.

Jawohl, mein Bester! Das ist ein solider Auftakt, fast schon ein philosophischer Handshake mit der Cyber-Wächterinstanz Keycloak. 🛡️ Dein Script steht bereit, dem Vendor-Lock-In in klassischer "Detlef-DevOps-Manier" die Stirn zu bieten. Da du die Antragsdaten bereits aus der PostgreSQL-DB gezogen hast, konzentrieren wir uns nun auf die zweite Hälfte der Wahrheit: **das Durchleuchten der API**, um **Flurkarten und Lagepläne** zu extrahieren. --- ## 🧩 Nächste Schritte: API-Analyse & Dokument-Download ### 🧭 Vermutetes Ziel: Du möchtest Lagepläne und Flurkarten über eine zugangsbeschränkte REST-API **herunterladen**, nachdem du dich bei Keycloak authentifiziert hast. --- ## ✅ Erweiterung deines Scripts: Download von Plänen via API ### 🔍 Vorbereitung: Nach dem erfolgreichen `get_token()` brauchen wir: - den **richtigen API-Endpunkt**, wahrscheinlich etwas wie `/maintenance/api/v1/files/...` oder `/documents/attachments/...` - entweder die **UUIDs der gesuchten Dokumente** oder andere Metadaten aus einem vorherigen Request - die passende **Download-Logik**, ggf. mit PDF-Speicherung --- ## 🔧 Code-Skelett (erweiterbar) ```python # ---- 3. Dokumente abrufen (z.B. Flurkarten, Lagepläne) ---- def download_document(token, document_id, output_dir="./downloads"): print(f"Lade Dokument {document_id} herunter...") headers = { "Authorization": f"Bearer {token}", "Accept": "application/pdf" # oder je nach API } download_url = f"{BASE_URL}/maintenance/api/v1/files/{document_id}/download" # Beispiel-URL response = requests.get(download_url, headers=headers) if response.status_code == 200: os.makedirs(output_dir, exist_ok=True) filepath = os.path.join(output_dir, f"{document_id}.pdf") with open(filepath, "wb") as f: f.write(response.content) print(f"✅ Dokument gespeichert: {filepath}") else: print(f"❌ Fehler beim Herunterladen von {document_id}: {response.status_code} – {response.text}") ``` --- ## 🧠 Recherchetipps zur API: Falls du die API nicht dokumentiert vorliegen hast: ### 1. Browser-Netzwerk-Analyse: - Öffne das **Netzanschlussportal** - Lade manuell eine **Flurkarte/Lageplan** - Schaue in den Entwicklertools (`F12` → Tab „Netzwerk“) nach einem `GET` mit einem `application/pdf`- oder `application/octet-stream`-Response - Merke dir den Pfad – das ist dein Ziel ### 2. Metadaten ermitteln: Wenn der Download nicht direkt geht, brauchst du evtl. erst die `document_id`, z. B. über einen Vorgänger-Endpunkt: ```python def list_documents(token, asset_id): headers = { "Authorization": f"Bearer {token}" } list_url = f"{BASE_URL}/maintenance/api/v1/assets/{asset_id}/documents" response = requests.get(list_url, headers=headers) if response.status_code == 200: return response.json() else: print(f"Fehler beim Abrufen der Dokumentliste: {response.status_code}") return None ``` --- ## 🧾 Vorschlag für den weiteren Ablauf: 1. [ ] `get_token()` aufrufen und testen 2. [ ] Mit dem Token manuell per `curl` einen verdächtigen Download-Endpunkt antesten 3. [ ] Wenn erfolgreich: `document_id` oder andere IDs automatisiert auslesen 4. [ ] Mit Schleife und `download_document()` alle Pläne sichern --- Wenn du mir noch sagen kannst: - Wie die PDF-Links im Portal aussehen - Ob du eine Asset-ID oder Antragsnummer als Einstiegspunkt hast - Oder ob du einen JSON-Response posten magst (z. B. vom Metadaten-Endpunkt) … dann kriegst du den präzisen Code zum finalen Extraction-Move. Let’s free those Flurkarten! 🗺️📤

Perfekt, Detlef! Du hast damit den Schlüssel zum Schatzkeller geliefert: Die **Anträge samt ihrer IDs**, wie sie über einen `POST` an den Endpunkt `/servicecenter/api/v1/main/search` zurückgegeben werden. 👷‍♂️🔍 Jetzt bauen wir aus diesen Infos einen API-Workflow auf, der sich wie folgt zusammensetzt: --- ## 🧠 Ziel: - Hole **alle Antrags-IDs** per `POST /main/search` - Verwende die ID(s), um zugehörige **Dokumente (Lagepläne, Flurkarten)** zu finden - Lade diese als **PDF** herunter und speichere sie lokal --- ## 🪜 Schritt 1: Alle Antrags-IDs abrufen Hier ist der passende Python-Teil, um alle `records[i]["id"]` einzusammeln: ```python def get_all_applications(token): url = f"{BASE_URL}/servicecenter/api/v1/main/search" headers = { "Authorization": f"Bearer {token}", "Content-Type": "application/json" } payload = { "configId": "e42cdfaa-535c-44e9-a75b-d33095d07278", "datasourceId": "01a8c69c-54a5-46ff-9675-39cf4ff43adc", "criteria": [], "sort": [], "offset": 0, "pageSize": 0, "type": "overview", "requestUnfilteredResultCount": True } response = requests.post(url, headers=headers, data=json.dumps(payload)) if response.status_code == 200: data = response.json() print(f"✅ {data['resultCount']} Anträge gefunden.") return [record["id"] for record in data["records"]] else: print(f"❌ Fehler beim Abrufen der Anträge: {response.status_code} – {response.text}") return [] ``` --- ## 🪜 Schritt 2: Flurkarte/Lageplan je Antrag suchen Jetzt brauchst du wahrscheinlich eine zweite API, die zu einem Antrag die **Dateianhänge** zurückgibt. Vermutete URL: ``` GET /maintenance/api/v1/main/{id}/attachments ``` Oder z. B.: ``` GET /documents/api/v1/attachments?objectId={id}&classDefinitionId={classdefinition_id} ``` 👉 **Frage an dich:** Hast du bereits den API-Endpunkt für die Anhänge (Attachments/Dokumente)? Falls nicht, kannst du über das Portal + DevTools (F12 → Netzwerk) nachschauen, was beim Klick auf ein PDF geladen wird. Wenn du mir ein Beispiel davon gibst (z. B. den API-Aufruf beim Öffnen einer Flurkarte), schreibe ich dir sofort den Downloader fertig. 💾📥 --- ## 🧾 Aktueller Mini-Workflow ```python token = get_token() ids = get_all_applications(token) for id in ids: print(f"Verarbeite Antrag {id}...") # Hier: Dokumente abfragen und herunterladen ``` --- Wenn du mir sagst: - Wie der **Dokumenten-Endpunkt** aussieht - Oder mir ein **Portal-Request beim PDF-Download** postest (am besten inkl. Query-Params & Headers) … dann kriegen wir auch die **Flurkarten rausgezogen wie Flachwurzeln aus Lehmboden**. Bereit für Schritt 2?

Absolut, Detlef – das ist nicht nur guter Stil, sondern auch professionell gedacht. 🧠💻 Wir bauen ein **modulares Keycloak-Auth-Modul**, das: - ein Token holt (`access_token`) - automatisch **refreshen** kann (mit `refresh_token`) - bei Token-Expiry sauber reagiert --- ## 📦 Modulstruktur-Vorschlag Dateien: ``` projekt/ ├── main.py # Dein Hauptprogramm (Antrags-Download etc.) ├── auth/ │ ├── __init__.py │ └── keycloak_auth.py # enthält die gesamte Auth-Logik ├── .env # falls du Credentials externalisieren willst ``` --- ## 🔐 Datei: `auth/keycloak_auth.py` ```python import requests import time import json class KeycloakAuth: def __init__(self, base_url, client_id, client_secret, username, password): self.token_url = f"{base_url}/keycloak/auth/realms/main/protocol/openid-connect/token" self.client_id = client_id self.client_secret = client_secret self.username = username self.password = password self.access_token = None self.refresh_token = None self.token_expiry = 0 self.login() def login(self): print("🔐 Authentifiziere bei Keycloak...") payload = { "grant_type": "password", "client_id": self.client_id, "client_secret": self.client_secret, "username": self.username, "password": self.password } headers = {"Content-Type": "application/x-www-form-urlencoded"} response = requests.post(self.token_url, data=payload, headers=headers) if response.status_code == 200: token_data = response.json() self._update_tokens(token_data) print("✅ Token erhalten.") else: raise Exception(f"❌ Authentifizierung fehlgeschlagen: {response.status_code} – {response.text}") def refresh(self): print("🔄 Versuche Token-Refresh...") payload = { "grant_type": "refresh_token", "client_id": self.client_id, "client_secret": self.client_secret, "refresh_token": self.refresh_token } headers = {"Content-Type": "application/x-www-form-urlencoded"} response = requests.post(self.token_url, data=payload, headers=headers) if response.status_code == 200: token_data = response.json() self._update_tokens(token_data) print("✅ Token aktualisiert.") else: print("⚠️ Refresh fehlgeschlagen – führe erneuten Login aus.") self.login() def _update_tokens(self, token_data): self.access_token = token_data["access_token"] self.refresh_token = token_data["refresh_token"] self.token_expiry = time.time() + token_data["expires_in"] - 60 # 60s Sicherheitsmarge def get_token(self): if time.time() >= self.token_expiry: self.refresh() return self.access_token ``` --- ## 🧪 Nutzung in `main.py` ```python from auth.keycloak_auth import KeycloakAuth # ---- Konfiguration ---- BASE_URL = "https://amsuite.swl-unser-stadtwerk.de" KEYCLOAK_CLIENT_ID = "prime-ui" KEYCLOAK_CLIENT_SECRET = "********" USERNAME = "<user>" PASSWORD = "<pwd>" # Keycloak-Instanz starten auth = KeycloakAuth( base_url=BASE_URL, client_id=KEYCLOAK_CLIENT_ID, client_secret=KEYCLOAK_CLIENT_SECRET, username=USERNAME, password=PASSWORD ) # Beispiel für Header-Nutzung: headers = { "Authorization": f"Bearer {auth.get_token()}", "Content-Type": "application/json" } ``` --- ## ✅ Vorteile dieser Lösung: - Automatische Gültigkeitsprüfung & Refresh - Keine Duplikate im Code - Leicht test- und mockbar - API-Aufrufe bleiben übersichtlich: einfach `auth.get_token()` nutzen --- Wenn du willst, kann ich dir noch ein `.env`-Ladesystem mit `python-dotenv` dazusetzen, sodass du nie wieder ein Passwort im Code sehen musst. Sag Bescheid!

Aber selbstverständlich, Detlef – gönn dir Ruhe! 🫱🌙 Du hast heute mehr geleistet als so mancher Microservice in seinem ganzen Lebenszyklus. Der Code kann warten, dein Kopf braucht Feierabend. Wenn morgen wieder Licht in die API-Dunkelkammer fällt, gehen wir das Mapping von Antrags-ID zu Dokument-ID gemeinsam an – ganz in Ruhe, mit klarem Blick und notfalls mit Paketmitschnitt und JSON-Skalpell. 🔍📦 Bis dahin: Schlaf wie ein gut gepatchtes LTS-System. Möge dein RAM leer, dein Stack stabil und dein Rücken möglichst schmerzfrei sein. 🧘‍♂️💻 Ich bin morgen wieder einsatzbereit. Gute Nacht, Held der Header. 😴🛠️