From 74d9d6b61fd6d604dfbf8b007daefd4838a60243 Mon Sep 17 00:00:00 2001 From: torsten Date: Mon, 9 Nov 2026 06:25:21 +0100 Subject: [PATCH] =?UTF-8?q?feat:=20Cloud-Sync=20=C3=BCber=20Dropbox=20und?= =?UTF-8?q?=20Google=20Drive?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - FTP-Sync durch Cloud-Backends ersetzt (Dropbox, Google Drive) - OAuth-Flow mit nutzereigenen Tokens und App-Key-Konfiguration - Zeit-Tooltips für Timeline-Labels und Abschnittsbanner beim Playback - Tests, Build-Konfiguration und Doku aktualisiert --- .gitignore | 3 + README.md | 2 + docs/architecture.md | 45 +- docs/builds.md | 15 +- docs/cloud-setup.md | 238 ++++++++ docs/credentials.example.txt | 28 +- docs/manual.md | 6 + docs/roadmap.md | 14 +- docs/sync.md | 129 +++-- rinkplanner/export_presets.cfg | 8 +- rinkplanner/scenes/whiteboard/whiteboard.tscn | 133 +++-- rinkplanner/src/core/sync/cloud_auth.gd | 152 ++++++ rinkplanner/src/core/sync/cloud_auth.gd.uid | 1 + rinkplanner/src/core/sync/cloud_http.gd | 305 +++++++++++ rinkplanner/src/core/sync/cloud_http.gd.uid | 1 + rinkplanner/src/core/sync/cloud_oauth_job.gd | 218 ++++++++ .../src/core/sync/cloud_oauth_job.gd.uid | 1 + rinkplanner/src/core/sync/dropbox_store.gd | 279 ++++++++++ .../src/core/sync/dropbox_store.gd.uid | 1 + rinkplanner/src/core/sync/ftp_client.gd | 514 ------------------ rinkplanner/src/core/sync/ftp_client.gd.uid | 1 - .../src/core/sync/google_drive_store.gd | 409 ++++++++++++++ .../src/core/sync/google_drive_store.gd.uid | 1 + rinkplanner/src/core/sync/remote_store.gd | 60 ++ rinkplanner/src/core/sync/remote_store.gd.uid | 1 + rinkplanner/src/core/sync/routine_sync.gd | 148 +++-- rinkplanner/src/core/sync/sync_app_config.gd | 92 ++++ .../src/core/sync/sync_app_config.gd.uid | 1 + .../whiteboard/ctrl/whiteboard_controller.gd | 474 ++++++++++++++-- .../src/whiteboard/view/rink_canvas.gd | 130 +++++ .../whiteboard/view/timeline_label_lane.gd | 73 ++- rinkplanner/sync_apps.example.cfg | 21 + rinkplanner/tests/README.md | 2 +- rinkplanner/tests/run_playback_tests.gd | 61 +++ rinkplanner/tests/run_sync_tests.gd | 214 ++++++-- tools/sync_apps_config.sh | 76 +++ 36 files changed, 3040 insertions(+), 817 deletions(-) create mode 100644 docs/cloud-setup.md create mode 100644 rinkplanner/src/core/sync/cloud_auth.gd create mode 100644 rinkplanner/src/core/sync/cloud_auth.gd.uid create mode 100644 rinkplanner/src/core/sync/cloud_http.gd create mode 100644 rinkplanner/src/core/sync/cloud_http.gd.uid create mode 100644 rinkplanner/src/core/sync/cloud_oauth_job.gd create mode 100644 rinkplanner/src/core/sync/cloud_oauth_job.gd.uid create mode 100644 rinkplanner/src/core/sync/dropbox_store.gd create mode 100644 rinkplanner/src/core/sync/dropbox_store.gd.uid delete mode 100644 rinkplanner/src/core/sync/ftp_client.gd delete mode 100644 rinkplanner/src/core/sync/ftp_client.gd.uid create mode 100644 rinkplanner/src/core/sync/google_drive_store.gd create mode 100644 rinkplanner/src/core/sync/google_drive_store.gd.uid create mode 100644 rinkplanner/src/core/sync/remote_store.gd create mode 100644 rinkplanner/src/core/sync/remote_store.gd.uid create mode 100644 rinkplanner/src/core/sync/sync_app_config.gd create mode 100644 rinkplanner/src/core/sync/sync_app_config.gd.uid create mode 100644 rinkplanner/sync_apps.example.cfg create mode 100755 tools/sync_apps_config.sh diff --git a/.gitignore b/.gitignore index c42dc06..8a1af41 100644 --- a/.gitignore +++ b/.gitignore @@ -35,3 +35,6 @@ docs/.credentials* # Editor-Swap-Dateien *.swp *.swo + +# OAuth-App-Zugaenge (werden per tools/sync_apps_config.sh erzeugt) +rinkplanner/sync_apps.cfg diff --git a/README.md b/README.md index f024aa6..ef2451d 100644 --- a/README.md +++ b/README.md @@ -11,3 +11,5 @@ Planner for Figure Skating free skate - **3D-Assets:** [`docs/assets.md`](docs/assets.md) - **Rotoscoping:** [`docs/rotoscoping.md`](docs/rotoscoping.md) - **Builds:** [`docs/builds.md`](docs/builds.md) +- **Kür-Sync (Google Drive/Dropbox):** [`docs/sync.md`](docs/sync.md) +- **Cloud-Sync einrichten:** [`docs/cloud-setup.md`](docs/cloud-setup.md) diff --git a/docs/architecture.md b/docs/architecture.md index bffa560..49f1c7b 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -339,14 +339,17 @@ Fahrtrichtung. sichtbar sind. Punktmarker halten die Ankunftsrichtung, Pirouetten drehen den Marker während der Standzeit mit 1,5 Umdrehungen pro Sekunde. Während des Playbacks wird die aktuelle Section hervorgehoben, - ohne die Bearbeitungs-Section zu wechseln. Steuerung: Play/Pause, Reset, + ohne die Bearbeitungs-Section zu wechseln. Ein **▶** markiert sie in der + Abschnittsliste; ihr Name erscheint kurz oben auf der Eisfläche und blendet + sich innerhalb von zwei Sekunden aus. Steuerung: Play/Pause, Reset, Timeline-Scrubbing und Geschwindigkeit 0,25×–2,0×. Ein optionales Musikstück (MP3/OGG/WAV) liegt neben der Kür-JSON in `user://routines/` und läuft über einen `AudioStreamPlayer` auf derselben Zeitbasis: Start, Pause, Reset, Scrubbing und Geschwindigkeit wirken auf Bild und Ton. Über der Timeline liegt eine Label-Spur: Labels von Segmenten und Kürzel von Elementen ohne Freitext erscheinen schräg an ihrem Startzeitpunkt (auch - Elemente mit 0 s Standzeit); ein Klick in die Spur legt ein eigenes, + Elemente mit 0 s Standzeit); beim Überfahren zeigt ein Tooltip den + Zeitpunkt im Track. Ein Klick in die Spur legt ein eigenes, frei beschriftetes Timeline-Label an, das per Klick wieder bearbeitet oder gelöscht werden kann. Ein Wechsel des aktiven Abschnitts setzt Marker, Timeline-Slider und Label-Spur an den Anfang dieses Abschnitts; eine @@ -483,14 +486,17 @@ ggf. eines nach `touchend` (300-ms-Guard). - **Lokale Daten:** `user://` liegt pro Plattform getrennt (Linux `~/.local/share/godot/app_userdata/Rinkplanner/`, Android im app-internen Speicher). -- **Kontosync:** manueller FTP-/FTPS-Abgleich der `.json`- und - Legacy-`.tres`-Dateien über `FtpClient`, `SyncPlan` und `RoutineSync`; - Details in `docs/sync.md`. Zugangsdaten liegen in `user://sync.cfg`, der - letzte gemeinsame Stand in `user://sync_state.cfg`. Beim ersten Abgleich - einer beidseitig vorhandenen Datei übernimmt die Serverfassung den Namen, - die lokale bleibt als `(Lokal …)`-Kopie; bei einem echten Konflikt bleibt - die lokale Fassung Hauptdatei und die Serverfassung kommt als - `(Server …)`-Kopie dazu. Konfliktnamen behalten die jeweilige Endung. +- **Kontosync:** manueller Cloud-Abgleich der `.json`- und + Legacy-`.tres`-Dateien über `RemoteStore`, `DropboxStore`, + `GoogleDriveStore`, `SyncPlan` und `RoutineSync`; Details in + `docs/sync.md`, Einrichtung der OAuth-Apps in `docs/cloud-setup.md`. + Jeder Nutzer verbindet sein eigenes Google-Drive- oder Dropbox-Konto; + Refresh-Tokens liegen in `user://sync.cfg`, der letzte gemeinsame Stand in + `user://sync_state.cfg`. Beim ersten Abgleich einer beidseitig vorhandenen + Datei übernimmt die Cloud-Fassung den Namen, die lokale bleibt als + `(Lokal …)`-Kopie; bei einem echten Konflikt bleibt die lokale Fassung + Hauptdatei und die Cloud-Fassung kommt als `(Server …)`-Kopie dazu. + Konfliktnamen behalten die jeweilige Endung. ## 7. Tests @@ -542,10 +548,10 @@ Aktueller Stand: - **History:** 53 Assertions für Undo/Redo von Segmenten, Kanten, Labels, Sections, Zeichengesten und Griff-Bearbeitung, Toolbar-Buttons, Erhalt der Ansicht sowie das Zurücksetzen der Historie. -- **Playback:** 45 Assertions für Dauer/Timeline, Vorwärts-/Rückwärts- - Blickrichtung, Section-Hervorhebung, Play/Pause/Reset inklusive +- **Playback:** 99 Assertions für Dauer/Timeline, Vorwärts-/Rückwärts- + Blickrichtung, Section-Hervorhebung und -Banner, Play/Pause/Reset inklusive Button-Verdrahtung, Scrubbing, Geschwindigkeitswechsel, Standzeiten von - Elementen und die Rotation des Markers in einer Pirouette. + Elementen, Markerrotation in einer Pirouette sowie Timeline-Tooltips. - **Timing:** 41 Assertions für Dauer-/Tempo-Kopplung, Level-Presets, Kalibrierung, Undo, Persistenz und Schema-1-Migration. - **Export:** 31 Assertions für SVG-Struktur, Titel-Escaping, Segment-Labels, @@ -558,11 +564,11 @@ Aktueller Stand: Leistenlayout bei 1024 und 1400 px. - **Performance:** Stresstest mit 480 Segmenten in 12 Sections; die mittlere Redraw-Zeit muss unter 120 ms bleiben (aktuell ca. 7–10 ms). -- **Sync:** 34 Assertions für Vergleichsregeln, Konfliktnamen (JSON und - Legacy-`.tres`), Zeitstempel, PASV/EPSV/MDTM-Parsing, Sync-Stand und die - Einstellungs-Verdrahtung. - Der FTP-Client wurde zusätzlich gegen den echten Zielserver geprüft - (Upload, Download, Übernahme, Konflikt, Aufräumen). +- **Sync:** 59 Assertions für Vergleichsregeln, Konfliktnamen (JSON und + Legacy-`.tres`), Zeitstempel, URL/PKCE-Helfer, Cloud-Pfade, App-Konfiguration, + Sync-Stand und die Einstellungs-Verdrahtung. Die echten Cloud-APIs werden + nicht in den automatischen Tests angesprochen (OAuth erfordert ein + Testkonto); der Ablauf ist in `docs/cloud-setup.md` beschrieben. - **3D-Assets:** 57 Assertions für Manifest-Schema, Pfade, FTP-Pfade, Platzierung, Rig-Metadaten, Animationen, Hashes und – falls synchronisiert – Größe, SHA-256 sowie die 8-Bone-Gewichte der GLB-Datei. @@ -615,8 +621,7 @@ Viewport-Screenshot; sie ersetzen die headless Tests nicht. sich im Praxisbetrieb. 9. **Dateinamen:** Die Normalisierung ersetzt Leerzeichen und entfernt Pfadzeichen, transliteriert aber keine Umlaute. Für Windows und den - geplanten FTP-Sync ist zu prüfen, ob eine ASCII-Normalisierung robuster - ist. + Cloud-Sync ist zu prüfen, ob eine ASCII-Normalisierung robuster ist. 10. **Snapshot-Clone:** `_clone_routine()` kopiert die Modellfelder manuell. Neue Felder am Modell müssen dort ergänzt werden, sonst fehlen sie in Undo/Redo-Snapshots. diff --git a/docs/builds.md b/docs/builds.md index b2be5e8..c56f193 100644 --- a/docs/builds.md +++ b/docs/builds.md @@ -27,6 +27,11 @@ Texturen in den Exporten liegt (`docs/assets.md`), sind die Builds etwa Export den Platzhalter. - Export-Templates derselben Version unter `~/.local/share/godot/export_templates/4.7.2.stable/` +- Für den Cloud-Sync: `rinkplanner/sync_apps.cfg` mit den OAuth-App-Zugängen. + Die Datei wird aus `docs/credentials.txt` erzeugt: + `./tools/sync_apps_config.sh`; Einrichtung in `docs/cloud-setup.md`. + Ohne die Datei baut die App, zeigt beim Verbinden aber einen + Konfigurationshinweis. - Für Android zusätzlich JDK 17 + Android SDK (siehe unten) ## Desktop bauen @@ -200,7 +205,9 @@ auf `tools/sync_assets.sh --sync` ab. Für einen reinen Starttest ohne ## Kontosync -Der manuelle Sync über FTP lädt die neuesten `.json`-Dateien -(Legacy-`.tres` weiterhin) je Kür hoch bzw. herunter, Konflikte bleiben als -Kopien mit Zeitstempel erhalten. Zugangsdaten liegen in den -App-Einstellungen (`user://`), nicht im Repository. +Der manuelle Sync über Google Drive oder Dropbox lädt die neuesten +`.json`-Dateien (Legacy-`.tres` weiterhin) je Kür hoch bzw. herunter, +Konflikte bleiben als Kopien mit Zeitstempel erhalten. Jedes Gerät verbindet +das eigene Cloud-Konto; Refresh-Tokens liegen in den App-Einstellungen +(`user://`), nicht im Repository. Details in `docs/sync.md` und +`docs/cloud-setup.md`. diff --git a/docs/cloud-setup.md b/docs/cloud-setup.md new file mode 100644 index 0000000..d028696 --- /dev/null +++ b/docs/cloud-setup.md @@ -0,0 +1,238 @@ +# Cloud-Sync einrichten (Google Drive / Dropbox) + +Rinkplanner speichert Kürdateien und Musik im **eigenen Cloud-Konto jedes +Nutzers**. Dafür registriert der Entwickler einmalig eine OAuth-App pro +Anbieter. Nutzer melden sich in ihrem Browser mit ihrem eigenen Konto an; die +App sieht niemals deren Passwort. + +## Warum keine E-Mail-/Passwort-Anmeldung? + +Google Drive und Dropbox haben die Anmeldung mit Benutzername und Passwort +über ihre APIs abgeschaltet. Ein `GOOGLE_PASSWORD` oder `DROPBOX_PASSWORD` in +`docs/credentials.txt` kann deshalb nicht verwendet werden. Nötig sind: + +- eine **App-Registrierung** (Client-ID/App-Key) für Rinkplanner, +- pro Nutzer ein **Refresh-Token** aus dem OAuth-Flow. + +Die App-Registrierung ist öffentlich (vergleichbar mit einem Paketnamen). Der +Refresh-Token ist das eigentliche Geheimnis und bleibt auf dem Gerät des +Nutzers in `user://sync.cfg`. + +## Google Drive + +1. In der [Google Cloud Console](https://console.cloud.google.com/) ein + Projekt anlegen (z. B. `Rinkplanner`). +2. **APIs & Dienste → Bibliothek → Google Drive API** aktivieren. +3. **OAuth-Zustimmungsbildschirm** einrichten: + - Nutzertyp **Extern** + - App-Name `Rinkplanner`, Support- und Entwickler-E-Mail + - Scopes: + - `https://www.googleapis.com/auth/drive.file` + - `openid` + - `email` + - Solange die App im Status **Testing** ist, müssen Testkonten unter + „Testnutzer“ eingetragen werden. Refresh-Tokens aus dem Testing-Status + laufen nach sieben Tagen ab; für den Dauerbetrieb die App + veröffentlichen („In Produktion“). +4. **Anmeldedaten → Anmeldedaten erstellen → OAuth-Client-ID**: + - Anwendungstyp **TVs and Limited Input devices** (Device Flow). + - Die Client-ID und das Client-Secret notieren. +5. Werte in `docs/credentials.txt` eintragen: + + ```ini + GOOGLE_CLIENT_ID=... + GOOGLE_CLIENT_SECRET=... + ``` + +6. `./tools/sync_apps_config.sh` ausführen. Das schreibt die App-Werte nach + `rinkplanner/sync_apps.cfg` (gitignored, wird in den Build eingebettet). + +`drive.file` ist ein nicht-sensibler Scope: Die App darf nur Dateien sehen, +die sie selbst angelegt hat. Sie kann nicht das übrige Google Drive des +Nutzers lesen. Rinkplanner legt dafür den Ordner `Rinkplanner` an. + +## Dropbox + +1. In der [Dropbox App Console](https://www.dropbox.com/developers/apps) eine + App anlegen. +2. **Zugriffstyp: App folder** (nicht „Full Dropbox“). Damit landet alles in + `Apps//` und Rinkplanner sieht keine anderen Dateien. Der + App-Name bestimmt den Ordnernamen; nach der Produktionsfreigabe ist er + nicht mehr änderbar. +3. **Permissions** setzen: + - `files.content.read` (Download) + - `files.content.write` (Upload/Überschreiben) + - `files.metadata.read` (Ordner auflisten) + - `files.metadata.write` (Zielordner anlegen, umbenennen, löschen) + - `account_info.read` (nur für die Anzeige der Konto-E-Mail) + + Änderungen mit **Save changes** speichern. Bereits verbundene Konten + müssen sich danach neu verbinden, weil der Token die alten Rechte behält. +4. **Settings → OAuth 2**: + - **Redirect-URI leer lassen** (wir nutzen den Code-Flow ohne Redirect). + - **Allow public clients / PKCE** aktivieren, falls vorhanden. +5. **App Key** notieren. Ein App Secret ist für den PKCE-Flow nicht nötig; + optional kann es ebenfalls eingetragen werden. +6. Werte in `docs/credentials.txt` eintragen: + + ```ini + DROPBOX_APP_KEY=... + # optional: + DROPBOX_APP_SECRET=... + ``` + +7. `./tools/sync_apps_config.sh` ausführen. +8. **Settings → App configuration → Development users**: **Enable additional + users** aktivieren, sonst kann nur dein eigenes Dropbox-Konto die App + verbinden. In der Development-Phase sind bis zu 500 Nutzer möglich. + +Der Dropbox-Flow nutzt **PKCE ohne Redirect-URI**: Nach der Anmeldung zeigt +Dropbox einen Autorisierungscode an, den der Nutzer in Rinkplanner einfügt. +Das funktioniert auf Desktop und Android ohne lokalen Callback-Server. + +## Veröffentlichungsstatus: Testing vs. Produktion + +„Veröffentlichen“ ist keine Veröffentlichung im App-Store, sondern der +Wechsel der OAuth-App vom Test- in den Produktivstatus beim jeweiligen +Anbieter. Das ist nötig, damit Tokens nicht ablaufen und beliebig viele +Nutzer das Konto verbinden können. + +### Google Drive + +| | Testing | In Produktion | +| :--- | :--- | :--- | +| Nutzer | max. 100 Testnutzer | beliebige Google-Konten | +| Refresh-Token | **läuft 7 Tage nach der Zustimmung ab** | bleibt gültig, bis der Nutzer den Zugriff widerruft | +| Warnung | „Ungeprüfte App“ möglich | für `drive.file` in der Regel keine Scope-Prüfung | + +Die 7-Tage-Regel gilt, weil Rinkplanner neben `openid`/`email` auch +`drive.file` anfragt. Die Ausnahme für reine Anmelde-Scopes greift hier +nicht. + +**Konkret zu tun:** + +1. Im Google-Cloud-Projekt unter **Google Auth Platform → Branding**: + App-Name, Support-E-Mail, Entwicklerkontakt, Startseite, Datenschutz-URL + und autorisierte Domain eintragen. Diese Links sind für externe + Produktions-Apps erforderlich. +2. Unter **Audience** auf **Publish app** klicken. Der Status wechselt zu + **In production**. +3. Eine **Markenprüfung** kann nötig sein, damit Name und Logo auf dem + Zustimmungsbildschirm erscheinen. Sie ist kein Security-Audit und dauert + laut Google meist nur Minuten, kann aber einige Tage brauchen. +4. Eine **Datenzugriffsprüfung** ist für `drive.file` nicht erforderlich, + weil der Scope als nicht-sensibel gilt. Ein teures Security-Assessment + ist damit nicht verbunden. +5. Nutzer, die schon im Testing-Status verbunden waren, müssen sich nach + dem Veröffentlichen **einmal neu verbinden**, damit sie einen + langlebigen Refresh-Token erhalten. + +Kosten: keine. Google verlangt für `drive.file` keine Verifikationsgebühr. + +Wenn nur du und ein paar Testgeräte den Sync nutzen, kannst du im +Testing-Status bleiben – dann muss jedes Gerät wöchentlich neu verbinden. +Für den echten Betrieb ist „In production“ die richtige Wahl. + +### Dropbox + +| | Development | Production | +| :--- | :--- | :--- | +| Nutzer | bis 500 verbundene Dropbox-Konten | unbegrenzt | +| Review | erst ab 50 verbundenen Nutzern (oder early review) | erforderlich | +| App-Name | änderbar | **nach der Freigabe nicht mehr änderbar** | + +**Konkret zu tun:** + +1. In der Dropbox App Console unter **Branding** ein App-Icon hinterlegen. +2. Unter **Settings → App configuration → Apply for production** den Antrag + ausfüllen: wie die App die API nutzt, warum App-Folder-Zugriff reicht, + Datenschutz-URL usw. +3. Der Antrag wird regulär erst geprüft, wenn die App **50 Nutzer** verbunden + hat. Ab 50 Nutzern hast du zwei Wochen Zeit, die Produktionsfreigabe zu + erhalten; sonst werden weitere Verbindungen blockiert. +4. Nach der Freigabe sind unbegrenzt viele Nutzer möglich. Der App-Name + bleibt dann fest. + +Für eine kleine geschlossene Testgruppe reicht Development. Sobald +Rinkplanner an mehr als 50 Personen geht, sollte der Produktionsantrag +vorbereitet sein. + +Wichtig für die Musik: Dropbox genehmigt keine Apps, die +Urheberrechtsverletzungen fördern. Rinkplanner stellt keine Dateien bereit +und teilt keine Musik zwischen Nutzern; die App sollte auch im Store-Text +nicht so beworben werden. Musik im eigenen Konto des Nutzers ist der +vorgesehene Fall. + +## App-Werte ohne Repository-Datei + +`SyncAppConfig` liest die App-Zugänge in dieser Reihenfolge (spätere Quellen +überschreiben frühere): + +1. Umgebungsvariablen + `RINKPLANNER_GOOGLE_CLIENT_ID`, `RINKPLANNER_GOOGLE_CLIENT_SECRET`, + `RINKPLANNER_DROPBOX_APP_KEY`, `RINKPLANNER_DROPBOX_APP_SECRET` +2. `res://sync_apps.cfg` (beim Build eingebettet) +3. `user://sync_apps.cfg` (lokale Entwickler-Installation) + +Für Release-Builds muss `rinkplanner/sync_apps.cfg` vor dem Export existieren. +Fehlt sie, startet die App normal, zeigt beim Verbinden aber einen Hinweis, +dass der Cloud-Sync in diesem Build nicht eingerichtet ist. + +Die Datei wird am besten mit `./tools/sync_apps_config.sh` erzeugt. Godots +`ConfigFile`-Format erwartet Kommentare mit `;` und Strings in +Anführungszeichen (`dropbox_app_key="..."`); `#`-Kommentare oder unquoted +Werte führen zu einem Parse-Fehler. + +## Nutzerfluss in der App + +1. **Datei → Sync-Einstellungen…** +2. Anbieter wählen (Dropbox oder Google Drive). +3. **Verbinden…**: + - Google Drive: Rinkplanner zeigt einen Code und öffnet die + Google-Anmeldeseite. Nach der Bestätigung schließt sich der Dialog. + - Dropbox: Rinkplanner öffnet die Dropbox-Seite. Den dort angezeigten Code + in die App einfügen und **Verbinden** drücken. +4. Cloud-Ordner festlegen. Bei Dropbox leer lassen, dann liegt alles direkt + im App-Ordner `Apps/`. Bei Google Drive legt die App den Ordner + `Rinkplanner` an. +5. **Speichern**, danach **Datei → Jetzt synchronisieren**. + +Jedes Gerät (Desktop und Tablet) wird einmal verbunden. Beide Geräte können +dasselbe Konto verwenden; der Abgleich läuft über den Cloud-Ordner. + +## Lizenzen und Musikdateien + +- Musikdateien werden ausschließlich im Konto des Nutzers gespeichert. + Rinkplanner betreibt keinen Speicher und keine zentrale Kopie. +- Die App greift bei Google Drive nur auf `drive.file`-Dateien zu, bei Dropbox + nur auf den App-Ordner. Es gibt keinen Zugriff auf fremde Konten. +- Es gibt kein gemeinsames Rinkplanner-Konto, über das Musik weitergegeben + würde. Jeder Nutzer ist für die Rechte an seinen hochgeladenen Dateien + selbst verantwortlich. +- In der App und in der Datenschutzerklärung sollte dieser Hinweis stehen: + „Musikdateien werden im eigenen Cloud-Konto gespeichert. Für die + Nutzungsrechte ist der Nutzer verantwortlich.“ + +## Sicherheit + +- Nutzerpasswörter werden nie abgefragt und nie gespeichert. +- Refresh-Tokens liegen in `user://sync.cfg` (app-privat). Auf Android ist das + der interne App-Speicher; auf dem Desktop + `~/.local/share/godot/app_userdata/Rinkplanner/`. +- **Trennen** in den Sync-Einstellungen löscht den Token auf dem Gerät. Die + Cloud-Dateien bleiben erhalten. +- Ein widerrufener Zugriff führt beim nächsten Sync zu einer verständlichen + Fehlermeldung; anschließend neu verbinden. +- Das Google-Client-Secret ist bei installierten Apps nicht geheim. Es + identifiziert die App, nicht den Nutzer. Dropbox nutzt PKCE und kommt ohne + Secret aus. + +## Veröffentlichung + +- Google: OAuth-Zustimmungsbildschirm veröffentlichen. `drive.file` ist + nicht-sensibel; trotzdem können Angaben zu Datenschutz und + Entwickleridentität verlangt werden. +- Dropbox: Produktionszugriff in der App Console beantragen. App-Folder-Apps + haben vor der Freigabe ein Nutzerlimit. +- Für Stores eine Datenschutzerklärung hinterlegen, die den Cloud-Zugriff und + die Musikverantwortung beschreibt. diff --git a/docs/credentials.example.txt b/docs/credentials.example.txt index 9b7eeaa..8cb1900 100644 --- a/docs/credentials.example.txt +++ b/docs/credentials.example.txt @@ -1,15 +1,37 @@ -# Vorlage für den FTP-Zugang (nie mit echten Werten einchecken). +# Vorlage für Entwickler-Zugänge (nie mit echten Werten einchecken). # Die echte Datei heißt docs/credentials.txt und ist in .gitignore eingetragen. # # Format: KEY=WERT, eine Zuweisung pro Zeile. '#' startet einen Kommentar. # +# --------------------------------------------------------------------------- +# FTP: nur noch für tools/sync_assets.sh --publish (Asset-Verteilung). +# Der Kür-Sync der App nutzt FTP nicht mehr. +# --------------------------------------------------------------------------- # FTP_URL: Hostname oder URL des FTP-Servers, z. B. ftp.example.org -# (Schema und Port sind optional: ftp://host:21) # FTP_USER: Benutzername des FTP-Kontos # FTP_PASSWORD: Passwort des FTP-Kontos # FTP_DIRECTORY: Zielverzeichnis relativ zum Login-Verzeichnis, z. B. rinkplanner - FTP_URL=ftp.example.org FTP_USER=benutzer FTP_PASSWORD=passwort FTP_DIRECTORY=rinkplanner + +# --------------------------------------------------------------------------- +# Cloud-Sync: OAuth-Apps von Rinkplanner (eine App je Anbieter, nicht je Nutzer) +# --------------------------------------------------------------------------- +# Die App-Zugänge werden mit tools/sync_apps_config.sh nach +# rinkplanner/sync_apps.cfg übernommen und beim Build eingebettet. +# Jeder Nutzer verbindet danach sein eigenes Google-/Dropbox-Konto in der App. +# E-Mail/Passwörter der Nutzer werden dafür nicht benötigt und nicht gespeichert. +# +# GOOGLE_CLIENT_ID / GOOGLE_CLIENT_SECRET: +# OAuth-Client vom Typ "TVs and Limited Input devices" (Device Flow) in der +# Google Cloud Console. Scope: https://www.googleapis.com/auth/drive.file +# DROPBOX_APP_KEY: +# App Key einer Dropbox-App mit "App folder"-Zugriff (Scoped access). +# DROPBOX_APP_SECRET: +# Optional; der PKCE-Flow funktioniert auch ohne Secret. +GOOGLE_CLIENT_ID= +GOOGLE_CLIENT_SECRET= +DROPBOX_APP_KEY= +DROPBOX_APP_SECRET= diff --git a/docs/manual.md b/docs/manual.md index ac04abd..1396f22 100644 --- a/docs/manual.md +++ b/docs/manual.md @@ -91,6 +91,8 @@ Kür-Ordner kopiert und in der Kür-JSON als Dateiname vermerkt. an diesem Zeitpunkt an; der Text wird im Dialog eingegeben. - **Bearbeiten:** Ein Klick auf ein goldenes eigenes Label öffnet den Dialog erneut. Dort lässt es sich umbenennen oder löschen. +- **Zeit-Tooltip:** Beim Überfahren eines Element-Labels zeigt ein Tooltip + dessen Zeitpunkt im Track, z. B. `1A · 12,3 s`. - Labels gehören zur Kür, werden mitgespeichert und über Undo/Redo sowie den Sync mitgeführt. @@ -102,6 +104,10 @@ Eine laufende Wiedergabe wird dabei angehalten; mit **Start** läuft sie ab dieser Stelle weiter. Die Position berücksichtigt alle davor liegenden Abschnitte inklusive Element-Standzeiten. +Während der Wiedergabe markiert ein **▶** den aktuellen Abschnitt in der +Liste rechts. Der Name des Abschnitts erscheint kurz oben auf der Eisfläche +und blendet sich innerhalb von zwei Sekunden weich aus. + ## Export **Datei → Exportieren…** schreibt nach `user://exports/`. Zur Wahl stehen: diff --git a/docs/roadmap.md b/docs/roadmap.md index eecbdc3..0b3de5e 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -30,7 +30,7 @@ Voraussetzung für Phase 1. - [x] Playback-Dot mit Blickrichtung, Timeline, Play/Pause/Reset und Geschwindigkeit 0,25×–2,0× - [x] Musikstück (MP3/OGG/WAV) je Kür laden; Wiedergabe, Scrubbing und - Geschwindigkeit laufen synchron zum Läufer; der FTP-Sync überträgt die + Geschwindigkeit laufen synchron zum Läufer; der Cloud-Sync überträgt die Musikdatei mit der Kür - [x] Timeline-Labels: Kür-Labels schräg auf der Timeline, eigene Labels per Klick anlegen, bearbeiten und löschen @@ -96,13 +96,14 @@ Voraussetzung für Phase 1. ### Erledigt: Kontosync (Desktop ↔ Tablet) -- [x] Sync-Einstellungen in der App (FTP-Host, Port, Benutzer, Passwort, - Verzeichnis, FTPS, Zertifikatsprüfung), Zugangsdaten unter `user://` +- [x] Sync-Einstellungen in der App (Anbieter, Konto verbinden/trennen, + Cloud-Ordner), Refresh-Tokens unter `user://` - [x] Manueller Sync: `.json` je Kür laden/hochladen (Legacy-`.tres` weiterhin), Sync-Stand lokal - [x] Konflikte als Kopien mit Server-Zeitstempel behalten - [x] Fortschritt und Zusammenfassung in der Oberfläche -- [x] FTP/FTPS-Client ohne externe Bibliothek +- [x] Google-Drive- und Dropbox-Backend ohne externe Bibliothek +- [x] Pro-Nutzer-OAuth (Google Device Flow, Dropbox PKCE) - [ ] Automatischer Sync im Hintergrund (später) - [ ] Konflikt-Zusammenführung in der Oberfläche (später) @@ -164,15 +165,14 @@ Voraussetzung für Phase 1. ### Zurückgestellt bis nach dem Proof-of-Concept -Wir sind bewusst noch im PoC. Der bestehende FTP-Sync und die aktuelle +Wir sind bewusst noch im PoC. Der bestehende Cloud-Sync und die aktuelle Oberfläche reichen für Tests; Komfort und Optik werden erst nach der fachlichen Validierung angefasst. - [ ] Automatischer Sync beim Start/Beenden - [ ] Konflikt-Zusammenführung in der Oberfläche - [ ] Löschweitergabe mit Bestätigung -- [ ] Sync über einen selbst gehosteten PHP-Webserver statt FTP - (Ziel: maximaler Datenaustausch-Komfort, z. B. HTTP/JSON-API) +- [ ] Optional: Sync-Ordner pro Anbieter getrennt konfigurieren - [ ] Hochformat-, Multi-Window- und DeX-Layout (obere Leiste umbruchfähig) - [ ] Visuelles UI-Refactoring (z. B. Buttons statt Comboboxen) inklusive Übernahme des Feedbacks der Tester diff --git a/docs/sync.md b/docs/sync.md index a3b9292..e695aa4 100644 --- a/docs/sync.md +++ b/docs/sync.md @@ -1,35 +1,41 @@ -# Kontosync über FTP +# Kür-Sync über Cloud-Speicher -Der Abgleich zwischen Desktop und Tablet läuft **manuell** über einen -FTP-Zugang. Es gibt kein Konto im Sinne einer Anmeldung auf einem Server: -Die Zugangsdaten sind das „Konto“, jedes Gerät bekommt dieselben Daten. +Der Abgleich zwischen Desktop und Tablet läuft **manuell** über den eigenen +Cloud-Speicher des Nutzers: Google Drive oder Dropbox. Es gibt kein Konto auf +einem Rinkplanner-Server. Jeder Nutzer verbindet sein eigenes Konto; die App +speichert nur den Refresh-Token lokal auf dem Gerät. ## Einrichten 1. Auf beiden Geräten: **Datei → Sync-Einstellungen…** -2. Eintragen: - - **Server** – Hostname des FTP-Servers (ohne `ftp://`) - - **Port** – normalerweise 21 - - **Benutzer / Passwort** - - **Verzeichnis** – Zielordner relativ zum Login, z. B. `rinkplanner` -3. **FTPS** eingeschaltet lassen (empfohlen). -4. **Server-Zertifikat prüfen** nur abschalten, wenn der Hoster ein - abweichendes Zertifikat nutzt (bei Shared Hosting häufig). Die Verbindung - bleibt verschlüsselt, der Server wird dann aber nicht kryptografisch - bestätigt. +2. **Anbieter** wählen: Dropbox oder Google Drive. +3. **Verbinden…** drücken und im Browser mit dem eigenen Konto anmelden: + - **Google Drive:** Die App zeigt einen Code und öffnet die + Google-Anmeldeseite. Nach der Bestätigung im Browser schließt sich der + Dialog automatisch. + - **Dropbox:** Die App öffnet die Dropbox-Seite. Den dort angezeigten Code + in das Feld einfügen und **Verbinden** drücken. +4. **Cloud-Ordner** festlegen. Bei Dropbox ist das standardmäßig der + App-Ordner selbst (`Apps/`); bei Google Drive legt die App + standardmäßig den Ordner `Rinkplanner` an. Ein leerer Eintrag bedeutet + „Cloud-Hauptordner des Anbieters“. 5. **Speichern**. Danach **Datei → Jetzt synchronisieren**. +Auf dem Tablet muss das Konto ebenfalls einmal verbunden werden. Beide Geräte +können dasselbe Google-/Dropbox-Konto verwenden; der Abgleich läuft über den +gemeinsamen Cloud-Ordner. + ## Was passiert -- Jede Kür liegt als `.json` unter `user://routines/` und wird 1:1 in das - FTP-Verzeichnis gespiegelt (flach, keine Unterordner). Gehört eine - Musikdatei zur Kür (`.mp3`, `.ogg`, `.wav`), liegt sie im selben Ordner und - wird mit denselben Regeln hoch- und heruntergeladen. Legacy-`.tres`- - Dateien werden weiterhin mit synchronisiert, damit bestehende Installationen - ihre Serverkopien nicht verlieren; neue Speicherungen schreiben `.json`. - Beim Laden wird eine `.tres` vor dem `ResourceLoader` gegen eine Whitelist +- Jede Kür liegt als `.json` unter `user://routines/` und wird 1:1 in den + Cloud-Ordner gespiegelt (flach, keine Unterordner). Gehört eine Musikdatei + zur Kür (`.mp3`, `.ogg`, `.wav`), liegt sie im selben Ordner und wird mit + denselben Regeln hoch- und heruntergeladen. Legacy-`.tres`-Dateien werden + weiterhin mit synchronisiert, damit bestehende Installationen ihre + Cloud-Kopien nicht verlieren; neue Speicherungen schreiben `.json`. Beim + Laden wird eine `.tres` vor dem `ResourceLoader` gegen eine Whitelist geprüft (nur Modellskripte, kein eingebettetes GDScript). - Der Sync vergleicht pro Datei den letzten gemeinsamen Stand (`user://sync_state.cfg`) mit den aktuellen Zeitstempeln: @@ -37,12 +43,12 @@ Danach **Datei → Jetzt synchronisieren**. | Lage | Aktion | | :--- | :--- | | nur lokal, noch nie synchronisiert | hochladen | -| nur auf dem Server | herunterladen | +| nur in der Cloud | herunterladen | | seit dem letzten Sync nur lokal geändert | hochladen | -| seit dem letzten Sync nur auf dem Server geändert | herunterladen | -| beidseitig geändert (seit dem letzten Sync) | **Konflikt**: lokale Fassung bleibt Hauptdatei, Serverfassung kommt als `(Server …)`-Kopie dazu | +| seit dem letzten Sync nur in der Cloud geändert | herunterladen | +| beidseitig geändert (seit dem letzten Sync) | **Konflikt**: lokale Fassung bleibt Hauptdatei, Cloud-Fassung kommt als `(Server …)`-Kopie dazu | | Datei auf einer Seite gelöscht | nichts tun (keine Löschweitergabe) | -| erster Sync, Datei auf beiden Seiten | **Server übernimmt**: Serverfassung wird Hauptdatei, lokale Fassung bleibt als `(Lokal …)`-Kopie | +| erster Sync, Datei auf beiden Seiten | **Cloud übernimmt**: Cloud-Fassung wird Hauptdatei, lokale Fassung bleibt als `(Lokal …)`-Kopie | ### Wie kommt eine Kür vom Desktop aufs Tablet? @@ -55,11 +61,11 @@ Kür-Titel entsteht). Eine Kür mit demselben Namen auf beiden Geräten ist kein „Update“, sondern eine Kollision: - **Erster Sync einer Datei auf beiden Seiten** (kein gemeinsamer Stand): - Die **Serverfassung übernimmt den Namen**, die lokale Fassung bleibt als + Die **Cloud-Fassung übernimmt den Namen**, die lokale Fassung bleibt als `name (Lokal JJJJ-MM-TT HHMM).json` daneben. So bekommt ein neues Gerät die gemeinsame Version, ohne die lokale Arbeit zu verlieren. - **Beide Seiten seit dem letzten Sync geändert**: Die lokale Fassung bleibt - Hauptdatei, die Serverfassung kommt als + Hauptdatei, die Cloud-Fassung kommt als `name (Server JJJJ-MM-TT HHMM).json` dazu. Beim nächsten Sync wird diese Kopie als neue Kür hochgeladen. Zusammenführen musst du selbst. Die Kopien behalten die Endung der Ausgangsdatei; bei Legacy-`.tres` @@ -81,20 +87,27 @@ Kür öffnen und bearbeiten. | Datei | Aufgabe | | :--- | :--- | -| `src/core/sync/ftp_client.gd` | FTP/FTPS-Client (USER/PASS, AUTH TLS + PROT P, EPSV/PASV, MLSD, SIZE, RETR, STOR, DELE, MKD, RNFR/RNTO) | +| `src/core/sync/remote_store.gd` | gemeinsame Schnittstelle der Cloud-Anbieter | +| `src/core/sync/dropbox_store.gd` | Dropbox-API (App-Ordner, `files/list_folder`, `files/upload`, `files/download`, `files/move_v2`) | +| `src/core/sync/google_drive_store.gd` | Google-Drive-API v3 (`drive.file`-Scope, Ordner `Rinkplanner`, Multipart-Upload, `alt=media`-Download) | +| `src/core/sync/cloud_http.gd` | blockierender HTTPS-Client für den Worker-Thread | +| `src/core/sync/cloud_auth.gd` | Refresh-Token, Access-Token-Erneuerung | +| `src/core/sync/cloud_oauth_job.gd` | Google-Device-Flow und Dropbox-PKCE-Flow | +| `src/core/sync/sync_app_config.gd` | App-Client-ID/App-Key laden | | `src/core/sync/sync_plan.gd` | reine Vergleichslogik, Konfliktnamen, Zeitstempel | | `src/core/sync/routine_sync.gd` | Ablauf, Datei-Ersetzung, Sync-Stand | - Der Sync läuft in einem `Thread`; die Oberfläche bleibt bedienbar und pollt den Fortschritt in `_process`. -- Uploads gehen zuerst nach `name.uploading` und werden dann umbenannt - (falls der Server das verweigert: direkter Upload). +- Cloud-Uploads sind einzelne, atomare HTTP-Anfragen (Dropbox + `files/upload` mit `mode: overwrite`, Google Drive Multipart-Upload). Ein + zusätzliches `.uploading`-Umbenennen wie beim alten FTP-Sync entfällt. - Downloads landen in `name.part` und ersetzen die Zieldatei erst danach. - Heruntergeladene `.json`-Dateien werden als JSON validiert; Legacy-`.tres` - laufen vor dem Laden durch die Whitelist in `RoutineFile`. Ein präparierter - Server kann damit keine eingebetteten GDScripts ausführen. + laufen vor dem Laden durch die Whitelist in `RoutineFile`. Ein manipuliertes + Cloud-Konto kann damit keine eingebetteten GDScripts ausführen. - Neue Speicherungen sind JSON; der Sync akzeptiert weiterhin `.tres`, damit - bestehende Dateien auf Server und Tablet nicht verschwinden. + bestehende Dateien in der Cloud und auf dem Tablet nicht verschwinden. - Musikdateien werden als normale Anhänge der Kür behandelt: Die JSON nennt nur den Dateinamen (`music_file`), die Datei liegt daneben. Ändert sich die Musik auf einem Gerät, lädt der nächste Sync sie hoch; auf dem anderen Gerät @@ -102,22 +115,30 @@ Kür öffnen und bearbeiten. behalten die Audio-Endung (z. B. `kuer (Server …).mp3`). - Eigene Timeline-Labels stehen in der Kür-JSON (`timeline_labels`) und werden ohne Zusatzdateien mit der Kür übertragen. -- Zugangsdaten liegen in `user://sync.cfg` (Klartext, app-privat). Auf +- Refresh-Tokens liegen in `user://sync.cfg` (Klartext, app-privat). Auf Android ist das der interne App-Speicher, auf dem Desktop - `~/.local/share/godot/app_userdata/Rinkplanner/`. + `~/.local/share/godot/app_userdata/Rinkplanner/`. Nutzerpasswörter werden + nicht gespeichert. Nach einem Kontowechsel oder Anbieterwechsel wird + `user://sync_state.cfg` zurückgesetzt, damit alte Zeitstempel keinen + falschen Konflikt auslösen. - Android braucht die `INTERNET`-Berechtigung – ist im APK gesetzt. -## Erfahrungen mit dem Zielserver +## Datenschutz und Musiklizenzen -- Der Server spricht explizites FTPS (`AUTH TLS`), außerdem `MLST`, `MDTM`, - `MFMT` und `EPSV` – genau das, was der Abgleich braucht. -- Sein TLS-Zertifikat passt nicht zum Hostnamen (leeres CN/SAN). Deshalb muss - „Server-Zertifikat prüfen“ ausgeschaltet werden; die Übertragung bleibt - verschlüsselt. -- Der Zielordner existiert in Kleinschreibung. Die App wechselt direkt - hinein und legt ihn bei Bedarf per `MKD` an. -- Ein vollständiger Testlauf (Upload, Überspringen, Download, Übernahme, - Konflikt, Aufräumen) lief gegen den echten Server erfolgreich. +- Bei Google Drive nutzt die App den Scope `drive.file`: Sie sieht nur + Dateien, die Rinkplanner selbst angelegt hat, nicht das übrige Drive. +- Bei Dropbox ist die App auf einen **App-Ordner** beschränkt. +- Musikdateien werden im Konto des Nutzers gespeichert. Es gibt keinen + zentralen Rinkplanner-Speicher und keine Weitergabe zwischen Konten. Die + Verantwortung für die Nutzungsrechte liegt beim Nutzer. +- Die App zeigt diesen Hinweis in den Sync-Einstellungen und sollte ihn auch + in der Datenschutzerklärung für Stores führen. + +## Einrichtung der OAuth-Apps + +Die App-Registrierung bei Google und Dropbox, die nötigen Scopes und die +Werte in `docs/credentials.txt` stehen in +[`docs/cloud-setup.md`](cloud-setup.md). ## Grenzen @@ -126,7 +147,23 @@ Kür öffnen und bearbeiten. verhindert dann Datenverlust, nicht aber doppelte Dateien. - Löschungen werden nicht übertragen (bewusst, um Versehen nicht zu multiplizieren). -- Umbenennen einer Kür wirkt wie „neu lokal“ + „nur Server“: beide Fassungen +- Umbenennen einer Kür wirkt wie „neu lokal“ + „nur Cloud“: beide Fassungen landen nebeneinander. - Sehr große Kürsammlungen werden vollständig verglichen; für hunderte Dateien ist das noch unkritisch, für tausende wäre ein Manifest sinnvoll. +- Dropbox-Uploads sind auf 150 MB pro Datei begrenzt (App-Ordner-Apps). Für + Kür-JSONs und übliche Musikdateien reicht das; größere Dateien müssten + chunked hochgeladen werden. +- Google Drive erlaubt technisch mehrere Dateien mit demselben Namen. Der + Sync sucht die erste passende Datei und führt bestehende Duplikate aus + anderen Quellen nicht zusammen. + +## Migration vom FTP-Sync + +Der frühere FTP-/FTPS-Sync ist entfernt. Alte `user://sync.cfg`-Einträge +(`host`, `port`, `user`, `password`, `ftps`, `verify_certificate`) werden +ignoriert; beim ersten Öffnen der Sync-Einstellungen muss ein Cloud-Konto +verbunden werden. Die Dateien im alten FTP-Verzeichnis werden nicht +automatisch übernommen: Wer sie behalten will, kopiert sie einmalig manuell +in den Cloud-Ordner oder verbindet beide Geräte mit demselben Cloud-Konto und +lädt die lokalen Kürdateien hoch. diff --git a/rinkplanner/export_presets.cfg b/rinkplanner/export_presets.cfg index 95d6784..3c72376 100644 --- a/rinkplanner/export_presets.cfg +++ b/rinkplanner/export_presets.cfg @@ -7,7 +7,7 @@ advanced_options=false dedicated_server=false custom_features="" export_filter="all_resources" -include_filter="*.json,assets/external/characters/*.glb" +include_filter="*.json,assets/external/characters/*.glb,sync_apps.cfg" exclude_filter="tests/*,prototype/*,docs/*,addons/script-ide/*,addons/godot_ai_bridge/godot_ai_bridge.gd,addons/godot_ai_bridge/message_handler.gd,addons/godot_ai_bridge/ws_server.gd,assets/models/*,assets/external/characters/weights_rings*" export_path="build/linux/rinkplanner.x86_64" patches=PackedStringArray() @@ -39,7 +39,7 @@ advanced_options=false dedicated_server=false custom_features="" export_filter="all_resources" -include_filter="*.json,assets/external/characters/*.glb" +include_filter="*.json,assets/external/characters/*.glb,sync_apps.cfg" exclude_filter="tests/*,prototype/*,docs/*,addons/script-ide/*,addons/godot_ai_bridge/godot_ai_bridge.gd,addons/godot_ai_bridge/message_handler.gd,addons/godot_ai_bridge/ws_server.gd,assets/models/*,assets/external/characters/weights_rings*" export_path="build/windows/rinkplanner.exe" patches=PackedStringArray() @@ -94,7 +94,7 @@ advanced_options=false dedicated_server=false custom_features="" export_filter="all_resources" -include_filter="*.json,assets/external/characters/*.glb" +include_filter="*.json,assets/external/characters/*.glb,sync_apps.cfg" exclude_filter="tests/*,prototype/*,docs/*,addons/script-ide/*,addons/godot_ai_bridge/godot_ai_bridge.gd,addons/godot_ai_bridge/message_handler.gd,addons/godot_ai_bridge/ws_server.gd,assets/models/*,assets/external/characters/weights_rings*" export_path="build/macos/rinkplanner.zip" patches=PackedStringArray() @@ -214,7 +214,7 @@ advanced_options=false dedicated_server=false custom_features="" export_filter="all_resources" -include_filter="*.json,assets/external/characters/*.glb" +include_filter="*.json,assets/external/characters/*.glb,sync_apps.cfg" exclude_filter="tests/*,prototype/*,docs/*,addons/script-ide/*,addons/godot_ai_bridge/godot_ai_bridge.gd,addons/godot_ai_bridge/message_handler.gd,addons/godot_ai_bridge/ws_server.gd,assets/models/*,assets/external/characters/weights_rings*" export_path="build/android/rinkplanner.apk" patches=PackedStringArray() diff --git a/rinkplanner/scenes/whiteboard/whiteboard.tscn b/rinkplanner/scenes/whiteboard/whiteboard.tscn index 6c0735f..89eacf0 100644 --- a/rinkplanner/scenes/whiteboard/whiteboard.tscn +++ b/rinkplanner/scenes/whiteboard/whiteboard.tscn @@ -244,6 +244,7 @@ text = "+" tooltip_text = "Abschnitt hinzufügen" [node name="SectionScroll" type="ScrollContainer" parent="Layout/Content/SectionsPanel/SectionsVBox"] +unique_name_in_owner = true layout_mode = 2 size_flags_vertical = 3 horizontal_scroll_mode = 0 @@ -819,8 +820,8 @@ cancel_button_text = "Abbrechen" [node name="SyncSettingsDialog" type="ConfirmationDialog" parent="."] unique_name_in_owner = true -title = "Sync-Einstellungen (FTP)" -size = Vector2i(620, 620) +title = "Sync-Einstellungen" +size = Vector2i(620, 500) ok_button_text = "Speichern" cancel_button_text = "Abbrechen" @@ -828,7 +829,7 @@ cancel_button_text = "Abbrechen" offset_left = 12.0 offset_top = 12.0 offset_right = 608.0 -offset_bottom = 540.0 +offset_bottom = 430.0 theme_override_constants/separation = 10 [node name="SyncHint" type="Label" parent="SyncSettingsDialog/SyncBox"] @@ -836,7 +837,7 @@ custom_minimum_size = Vector2(560, 0) layout_mode = 2 theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) theme_override_font_sizes/font_size = 14 -text = "Zugangsdaten werden nur lokal unter user://sync.cfg gespeichert. Der Abgleich läuft manuell über Datei → Jetzt synchronisieren." +text = "Jedes Gerät verbindet sein eigenes Google- oder Dropbox-Konto. Rinkplanner speichert die Kürdateien und Musik nur in diesem Konto; es gibt keinen gemeinsamen Server." autowrap_mode = 2 [node name="SyncGrid" type="GridContainer" parent="SyncSettingsDialog/SyncBox"] @@ -845,82 +846,106 @@ theme_override_constants/h_separation = 10 theme_override_constants/v_separation = 8 columns = 2 -[node name="SyncHostLabel" type="Label" parent="SyncSettingsDialog/SyncBox/SyncGrid"] +[node name="SyncProviderLabel" type="Label" parent="SyncSettingsDialog/SyncBox/SyncGrid"] layout_mode = 2 -text = "Server" +text = "Anbieter" -[node name="SyncHostEdit" type="LineEdit" parent="SyncSettingsDialog/SyncBox/SyncGrid"] +[node name="SyncProviderOption" type="OptionButton" parent="SyncSettingsDialog/SyncBox/SyncGrid"] unique_name_in_owner = true custom_minimum_size = Vector2(330, 48) layout_mode = 2 size_flags_horizontal = 3 -placeholder_text = "ftp.example.org" - -[node name="SyncPortLabel" type="Label" parent="SyncSettingsDialog/SyncBox/SyncGrid"] -layout_mode = 2 -text = "Port" - -[node name="SyncPortEdit" type="LineEdit" parent="SyncSettingsDialog/SyncBox/SyncGrid"] -unique_name_in_owner = true -custom_minimum_size = Vector2(330, 48) -layout_mode = 2 -size_flags_horizontal = 3 -text = "21" - -[node name="SyncUserLabel" type="Label" parent="SyncSettingsDialog/SyncBox/SyncGrid"] -layout_mode = 2 -text = "Benutzer" - -[node name="SyncUserEdit" type="LineEdit" parent="SyncSettingsDialog/SyncBox/SyncGrid"] -unique_name_in_owner = true -custom_minimum_size = Vector2(330, 48) -layout_mode = 2 -size_flags_horizontal = 3 - -[node name="SyncPasswordLabel" type="Label" parent="SyncSettingsDialog/SyncBox/SyncGrid"] -layout_mode = 2 -text = "Passwort" - -[node name="SyncPasswordEdit" type="LineEdit" parent="SyncSettingsDialog/SyncBox/SyncGrid"] -unique_name_in_owner = true -custom_minimum_size = Vector2(330, 48) -layout_mode = 2 -size_flags_horizontal = 3 -secret = true [node name="SyncDirectoryLabel" type="Label" parent="SyncSettingsDialog/SyncBox/SyncGrid"] layout_mode = 2 -text = "Verzeichnis" +text = "Cloud-Ordner" [node name="SyncDirectoryEdit" type="LineEdit" parent="SyncSettingsDialog/SyncBox/SyncGrid"] unique_name_in_owner = true custom_minimum_size = Vector2(330, 48) layout_mode = 2 size_flags_horizontal = 3 -placeholder_text = "rinkplanner" +placeholder_text = "leer = Cloud-Hauptordner" -[node name="SyncFtpsCheck" type="CheckBox" parent="SyncSettingsDialog/SyncBox"] -unique_name_in_owner = true -custom_minimum_size = Vector2(0, 48) +[node name="SyncAccountRow" type="HBoxContainer" parent="SyncSettingsDialog/SyncBox"] layout_mode = 2 -button_pressed = true -text = "FTPS (verschlüsselte Verbindung)" +theme_override_constants/separation = 10 -[node name="SyncVerifyCheck" type="CheckBox" parent="SyncSettingsDialog/SyncBox"] -unique_name_in_owner = true -custom_minimum_size = Vector2(0, 48) +[node name="SyncAccountLabel" type="Label" parent="SyncSettingsDialog/SyncBox/SyncAccountRow"] layout_mode = 2 -button_pressed = true -text = "Server-Zertifikat prüfen" +text = "Konto" -[node name="SyncVerifyHint" type="Label" parent="SyncSettingsDialog/SyncBox"] +[node name="SyncAccountValue" type="Label" parent="SyncSettingsDialog/SyncBox/SyncAccountRow"] +unique_name_in_owner = true +layout_mode = 2 +size_flags_horizontal = 3 +text = "Nicht verbunden" +autowrap_mode = 2 + +[node name="SyncConnectButton" type="Button" parent="SyncSettingsDialog/SyncBox/SyncAccountRow"] +unique_name_in_owner = true +custom_minimum_size = Vector2(150, 44) +layout_mode = 2 +text = "Verbinden…" + +[node name="SyncHint2" type="Label" parent="SyncSettingsDialog/SyncBox"] custom_minimum_size = Vector2(560, 0) layout_mode = 2 theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) theme_override_font_sizes/font_size = 13 -text = "Nur abschalten, wenn der Server ein abweichendes Zertifikat nutzt (z. B. Shared Hosting)." +text = "Musikdateien liegen im eigenen Cloud-Konto. Für die Nutzungsrechte an der Musik ist der Nutzer verantwortlich. Zugangsdaten bleiben lokal unter user://sync.cfg; der Abgleich läuft manuell über Datei → Jetzt synchronisieren." autowrap_mode = 2 +[node name="CloudAuthDialog" type="ConfirmationDialog" parent="."] +unique_name_in_owner = true +title = "Cloud-Konto verbinden" +size = Vector2i(620, 430) +ok_button_text = "Weiter" +cancel_button_text = "Abbrechen" + +[node name="CloudAuthBox" type="VBoxContainer" parent="CloudAuthDialog"] +offset_left = 12.0 +offset_top = 12.0 +offset_right = 608.0 +offset_bottom = 360.0 +theme_override_constants/separation = 10 + +[node name="CloudAuthStatus" type="Label" parent="CloudAuthDialog/CloudAuthBox"] +unique_name_in_owner = true +custom_minimum_size = Vector2(560, 0) +layout_mode = 2 +text = "Anmeldung wird vorbereitet …" +autowrap_mode = 2 + +[node name="CloudAuthUrlEdit" type="LineEdit" parent="CloudAuthDialog/CloudAuthBox"] +unique_name_in_owner = true +custom_minimum_size = Vector2(560, 48) +layout_mode = 2 +editable = false +select_all_on_focus = true + +[node name="CloudAuthUserCode" type="Label" parent="CloudAuthDialog/CloudAuthBox"] +unique_name_in_owner = true +custom_minimum_size = Vector2(560, 0) +layout_mode = 2 +theme_override_font_sizes/font_size = 30 +horizontal_alignment = 1 + +[node name="CloudAuthCodeHint" type="Label" parent="CloudAuthDialog/CloudAuthBox"] +unique_name_in_owner = true +custom_minimum_size = Vector2(560, 0) +layout_mode = 2 +theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) +theme_override_font_sizes/font_size = 14 +text = "Code aus der Dropbox-Seite hier einfügen." +autowrap_mode = 2 + +[node name="CloudAuthCodeEdit" type="LineEdit" parent="CloudAuthDialog/CloudAuthBox"] +unique_name_in_owner = true +custom_minimum_size = Vector2(560, 52) +layout_mode = 2 +placeholder_text = "Autorisierungscode" + [node name="AutosaveTimer" type="Timer" parent="."] unique_name_in_owner = true wait_time = 1.5 diff --git a/rinkplanner/src/core/sync/cloud_auth.gd b/rinkplanner/src/core/sync/cloud_auth.gd new file mode 100644 index 0000000..946dd50 --- /dev/null +++ b/rinkplanner/src/core/sync/cloud_auth.gd @@ -0,0 +1,152 @@ +class_name CloudAuth +extends RefCounted + +## Holds the OAuth tokens of one provider for one user and refreshes the +## short-lived access token when needed. Tokens are stored by the controller in +## `user://sync.cfg`; this class never writes to disk. + +const GOOGLE_TOKEN_URL := "https://oauth2.googleapis.com/token" +const DROPBOX_TOKEN_URL := "https://api.dropboxapi.com/oauth2/token" +const EXPIRY_MARGIN_SECONDS := 60 + +var provider: String = "" +var client_id: String = "" +var client_secret: String = "" +var refresh_token: String = "" +var access_token: String = "" +var expires_at: int = 0 +var account: String = "" +var last_error: String = "" + + +func configure( + p_provider: String, + p_client_id: String, + p_client_secret: String, + tokens: Dictionary +) -> void: + provider = p_provider + client_id = p_client_id + client_secret = p_client_secret + refresh_token = str(tokens.get("refresh_token", "")) + access_token = str(tokens.get("access_token", "")) + expires_at = int(tokens.get("expires_at", 0)) + account = str(tokens.get("account", "")) + + +func ensure_access_token() -> String: + last_error = "" + if not access_token.is_empty() and Time.get_unix_time_from_system() < expires_at - EXPIRY_MARGIN_SECONDS: + return "" + if refresh_token.is_empty(): + last_error = "Nicht mit dem Cloud-Konto verbunden." + return last_error + + var http := CloudHttp.new() + var params := { + "grant_type": "refresh_token", + "refresh_token": refresh_token, + } + if provider == "google_drive": + params["client_id"] = client_id + params["client_secret"] = client_secret + else: + params["client_id"] = client_id + if not client_secret.is_empty(): + params["client_secret"] = client_secret + + var response := http.request( + HTTPClient.METHOD_POST, + _token_url(), + PackedStringArray(["Content-Type: application/x-www-form-urlencoded"]), + CloudHttp.form_encode(params).to_utf8_buffer() + ) + if response.is_empty(): + last_error = http.last_error + return last_error + + var data: Variant = CloudHttp.json_parse(response["body"]) + if int(response["status"]) != 200: + last_error = _friendly_error(data, response) + return last_error + if not data is Dictionary: + last_error = "Ungültige Token-Antwort des Anbieters." + return last_error + + _apply_token_response(data) + if access_token.is_empty(): + last_error = "Der Anbieter hat keinen Access-Token geliefert." + return last_error + return "" + + +func to_tokens() -> Dictionary: + return { + "refresh_token": refresh_token, + "access_token": access_token, + "expires_at": expires_at, + "account": account, + } + + +func _apply_token_response(data: Dictionary) -> void: + access_token = str(data.get("access_token", "")) + var new_refresh := str(data.get("refresh_token", "")) + if not new_refresh.is_empty(): + refresh_token = new_refresh + expires_at = ( + int(Time.get_unix_time_from_system()) + + maxi(60, int(data.get("expires_in", 3600))) + ) + var id_token := str(data.get("id_token", "")) + if account.is_empty() and not id_token.is_empty(): + account = CloudAuth.email_from_id_token(id_token) + + +func _token_url() -> String: + return GOOGLE_TOKEN_URL if provider == "google_drive" else DROPBOX_TOKEN_URL + + +func _friendly_error(data: Variant, response: Dictionary) -> String: + var detail := CloudHttp.error_text(data, response) + if provider == "google_drive" and detail.contains("invalid_grant"): + return ( + "Die Google-Anmeldung ist abgelaufen oder wurde widerrufen. " + + "Bitte das Konto erneut verbinden." + ) + if provider == "dropbox" and detail.contains("invalid_grant"): + return ( + "Die Dropbox-Anmeldung ist abgelaufen oder wurde widerrufen. " + + "Bitte das Konto erneut verbinden." + ) + return "Token-Erneuerung fehlgeschlagen: %s" % detail + + +static func tokens_from_response(data: Dictionary) -> Dictionary: + var tokens := { + "access_token": str(data.get("access_token", "")), + "refresh_token": str(data.get("refresh_token", "")), + "expires_at": ( + int(Time.get_unix_time_from_system()) + + maxi(60, int(data.get("expires_in", 3600))) + ), + "account": "", + } + var id_token := str(data.get("id_token", "")) + if not id_token.is_empty(): + tokens["account"] = email_from_id_token(id_token) + return tokens + + +static func email_from_id_token(id_token: String) -> String: + var parts := id_token.split(".") + if parts.size() < 2: + return "" + var payload := parts[1].replace("-", "+").replace("_", "/") + while payload.length() % 4 != 0: + payload += "=" + var raw := Marshalls.base64_to_raw(payload) + var data: Variant = JSON.parse_string(raw.get_string_from_utf8()) + if data is Dictionary: + return str((data as Dictionary).get("email", "")) + return "" diff --git a/rinkplanner/src/core/sync/cloud_auth.gd.uid b/rinkplanner/src/core/sync/cloud_auth.gd.uid new file mode 100644 index 0000000..31d1420 --- /dev/null +++ b/rinkplanner/src/core/sync/cloud_auth.gd.uid @@ -0,0 +1 @@ +uid://bh2kwi34xujd1 diff --git a/rinkplanner/src/core/sync/cloud_http.gd b/rinkplanner/src/core/sync/cloud_http.gd new file mode 100644 index 0000000..f7e354d --- /dev/null +++ b/rinkplanner/src/core/sync/cloud_http.gd @@ -0,0 +1,305 @@ +class_name CloudHttp +extends RefCounted + +## Small blocking HTTP client for the cloud sync. Runs on a worker thread, so +## it uses [HTTPClient] directly instead of the scene-tree [HTTPRequest] node. +## +## All helpers return plain data; network failures are reported through +## [member last_error] and an empty dictionary. + +const DEFAULT_TIMEOUT_MSEC := 30000 +const TRANSFER_TIMEOUT_MSEC := 300000 +const POLL_DELAY_MSEC := 5 +const USER_AGENT := "Rinkplanner/0.1 (Godot)" + +var last_error: String = "" + + +func request( + method: int, + url: String, + headers: PackedStringArray = PackedStringArray(), + body: PackedByteArray = PackedByteArray(), + timeout_msec: int = DEFAULT_TIMEOUT_MSEC, + redirects_left: int = 5 +) -> Dictionary: + last_error = "" + var parsed := parse_url(url) + if parsed.is_empty(): + last_error = "Ungültige URL: %s" % url + return {} + + var client := HTTPClient.new() + var tls: TLSOptions = null + if str(parsed["scheme"]) == "https": + tls = TLSOptions.client() + var err := client.connect_to_host( + str(parsed["host"]), + int(parsed["port"]), + tls + ) + if err != OK: + last_error = "Verbindung zu %s fehlgeschlagen (Fehler %d)" % [parsed["host"], err] + return {} + + var deadline := Time.get_ticks_msec() + timeout_msec + if not _wait_connected(client, deadline): + client.close() + if last_error.is_empty(): + last_error = "Zeitüberschreitung beim Verbindungsaufbau zu %s" % parsed["host"] + return {} + + var request_headers := PackedStringArray(headers) + request_headers.append("User-Agent: " + USER_AGENT) + request_headers.append("Accept-Encoding: identity") + err = client.request_raw(method, str(parsed["path"]), request_headers, body) + if err != OK: + client.close() + last_error = "Anfrage konnte nicht gesendet werden (Fehler %d)" % err + return {} + + while client.get_status() == HTTPClient.STATUS_REQUESTING: + if Time.get_ticks_msec() > deadline: + client.close() + last_error = "Zeitüberschreitung beim Warten auf die Antwort" + return {} + client.poll() + OS.delay_msec(POLL_DELAY_MSEC) + + if not client.has_response(): + var status := client.get_status() + client.close() + last_error = _status_error(status) + return {} + + var response_status := client.get_response_code() + var response_headers := client.get_response_headers_as_dictionary() + var payload := PackedByteArray() + while client.get_status() == HTTPClient.STATUS_BODY: + if Time.get_ticks_msec() > deadline: + client.close() + last_error = "Zeitüberschreitung beim Lesen der Antwort" + return {} + client.poll() + var chunk := client.read_response_body_chunk() + if chunk.size() > 0: + payload.append_array(chunk) + else: + OS.delay_msec(POLL_DELAY_MSEC) + client.close() + + var location := header(response_headers, "location") + if ( + response_status in [301, 302, 303, 307, 308] + and not location.is_empty() + and redirects_left > 0 + ): + var target := resolve_url(url, location) + if not target.is_empty(): + var next_headers := headers + var target_parsed := parse_url(target) + if str(target_parsed.get("host", "")) != str(parsed["host"]): + next_headers = _without_sensitive_headers(headers) + var next_method := method + var next_body := body + if response_status == 303: + next_method = HTTPClient.METHOD_GET + next_body = PackedByteArray() + return request( + next_method, + target, + next_headers, + next_body, + timeout_msec, + redirects_left - 1 + ) + + return { + "status": response_status, + "headers": response_headers, + "body": payload, + } + + +func _wait_connected(client: HTTPClient, deadline: int) -> bool: + while true: + match client.get_status(): + HTTPClient.STATUS_RESOLVING, HTTPClient.STATUS_CONNECTING: + if Time.get_ticks_msec() > deadline: + last_error = "Zeitüberschreitung beim Verbindungsaufbau" + return false + client.poll() + OS.delay_msec(POLL_DELAY_MSEC) + HTTPClient.STATUS_CONNECTED: + return true + HTTPClient.STATUS_CANT_RESOLVE: + last_error = "Hostname konnte nicht aufgelöst werden" + return false + HTTPClient.STATUS_CONNECTION_ERROR: + last_error = "Netzwerkfehler beim Verbindungsaufbau" + return false + HTTPClient.STATUS_TLS_HANDSHAKE_ERROR: + last_error = "TLS-Handshake fehlgeschlagen" + return false + _: + last_error = _status_error(client.get_status()) + return false + return false + + +static func _status_error(status: int) -> String: + match status: + HTTPClient.STATUS_CANT_RESOLVE: + return "Hostname konnte nicht aufgelöst werden" + HTTPClient.STATUS_CONNECTION_ERROR: + return "Netzwerkverbindung fehlgeschlagen" + HTTPClient.STATUS_TLS_HANDSHAKE_ERROR: + return "TLS-Verbindung fehlgeschlagen" + HTTPClient.STATUS_DISCONNECTED: + return "Server hat die Verbindung getrennt" + _: + return "Unerwarteter Netzwerkstatus (%d)" % status + + +static func parse_url(url: String) -> Dictionary: + var scheme := "https" + var rest := url.strip_edges() + var scheme_end := rest.find("://") + if scheme_end >= 0: + scheme = rest.substr(0, scheme_end).to_lower() + rest = rest.substr(scheme_end + 3) + + var path_start := rest.find("/") + var host_port := rest + var path := "/" + if path_start >= 0: + host_port = rest.substr(0, path_start) + path = rest.substr(path_start) + if host_port.is_empty(): + return {} + + var host := host_port + var port := 443 if scheme == "https" else 80 + var colon := host_port.rfind(":") + if colon >= 0 and not host_port.substr(colon + 1).is_empty(): + var port_text := host_port.substr(colon + 1) + if port_text.is_valid_int(): + port = int(port_text) + host = host_port.substr(0, colon) + if host.is_empty(): + return {} + if scheme != "http" and scheme != "https": + return {} + return {"scheme": scheme, "host": host, "port": port, "path": path} + + +static func form_encode(values: Dictionary) -> String: + var parts := PackedStringArray() + for key: String in values.keys(): + parts.append( + str(key).uri_encode() + "=" + str(values[key]).uri_encode() + ) + return "&".join(parts) + + +static func json_parse(body: PackedByteArray) -> Variant: + if body.is_empty(): + return {} + var parser := JSON.new() + if parser.parse(body.get_string_from_utf8()) != OK: + return null + return parser.data + + +static func json_stringify(value: Variant) -> String: + return JSON.stringify(value, "", false) + + +## JSON with all non-ASCII characters escaped. Used for the Dropbox +## `Dropbox-API-Arg` header, which must stay ASCII even for umlauts. +static func json_stringify_ascii(value: Variant) -> String: + var text := json_stringify(value) + var out := "" + for index: int in range(text.length()): + var code := text.unicode_at(index) + if code < 128: + out += text.substr(index, 1) + elif code <= 0xFFFF: + out += "\\u%04x" % code + else: + var offset := code - 0x10000 + out += "\\u%04x\\u%04x" % [ + 0xD800 + (offset >> 10), + 0xDC00 + (offset & 0x3FF), + ] + return out + + +static func resolve_url(base_url: String, location: String) -> String: + var target := location.strip_edges() + if target.is_empty(): + return "" + if target.begins_with("http://") or target.begins_with("https://"): + return target + var base := parse_url(base_url) + if base.is_empty(): + return "" + var scheme := str(base["scheme"]) + var host := str(base["host"]) + var port := int(base["port"]) + var authority := "%s://%s:%d" % [scheme, host, port] + if target.begins_with("//"): + return scheme + ":" + target + if target.begins_with("/"): + return authority + target + var path := str(base["path"]) + var slash := path.rfind("/") + var directory := path.substr(0, slash + 1) if slash >= 0 else "/" + return authority + directory + target + + +static func _without_sensitive_headers(headers: PackedStringArray) -> PackedStringArray: + var result := PackedStringArray() + for value: String in headers: + var lower := value.to_lower() + if lower.begins_with("authorization:") or lower.begins_with("cookie:"): + continue + result.append(value) + return result + + +static func header(headers: Dictionary, name: String) -> String: + for key: String in headers.keys(): + if key.to_lower() == name.to_lower(): + return str(headers[key]) + return "" + + +static func error_text(data: Variant, response: Dictionary = {}) -> String: + if data is Dictionary: + var dict: Dictionary = data + if dict.has("error_description"): + return str(dict["error_description"]) + if dict.has("error_summary"): + return str(dict["error_summary"]) + var error: Variant = dict.get("error", null) + if error is Dictionary: + if error.has("message"): + return str(error["message"]) + if error.has("summary"): + return str(error["summary"]) + if error.has(".tag"): + return str(error[".tag"]) + for key: String in error.keys(): + if key != ".tag" and error[key] is Dictionary: + var nested: Dictionary = error[key] + if nested.has(".tag"): + return "%s: %s" % [key, nested[".tag"]] + return str(error) + if error is String and not error.is_empty(): + return error + if response.has("body"): + var text := (response["body"] as PackedByteArray).get_string_from_utf8() + if not text.strip_edges().is_empty(): + return text.strip_edges().substr(0, 300) + return "HTTP-Fehler" diff --git a/rinkplanner/src/core/sync/cloud_http.gd.uid b/rinkplanner/src/core/sync/cloud_http.gd.uid new file mode 100644 index 0000000..3aed9df --- /dev/null +++ b/rinkplanner/src/core/sync/cloud_http.gd.uid @@ -0,0 +1 @@ +uid://buoubgak6d4pf diff --git a/rinkplanner/src/core/sync/cloud_oauth_job.gd b/rinkplanner/src/core/sync/cloud_oauth_job.gd new file mode 100644 index 0000000..29ded74 --- /dev/null +++ b/rinkplanner/src/core/sync/cloud_oauth_job.gd @@ -0,0 +1,218 @@ +class_name CloudOAuthJob +extends RefCounted + +## Runs one OAuth authorisation on a worker thread. The controller polls the +## public fields from `_process` and keeps the UI responsive. No scene-tree +## access happens here. + +const GOOGLE_DEVICE_URL := "https://oauth2.googleapis.com/device/code" +const GOOGLE_SCOPES := "openid email https://www.googleapis.com/auth/drive.file" +const DROPBOX_AUTHORIZE_URL := "https://www.dropbox.com/oauth2/authorize" +const DROPBOX_ACCOUNT_URL := "https://api.dropboxapi.com/2/users/get_current_account" + +var provider: String = "" +var status: String = "" +var user_code: String = "" +var verification_url: String = "" +var error: String = "" +var done: bool = false +var cancelled: bool = false +var result: Dictionary = {} + + +func run_google_device(client_id: String, client_secret: String) -> void: + provider = "google_drive" + status = "Fordere Anmeldecode an …" + var http := CloudHttp.new() + var response := http.request( + HTTPClient.METHOD_POST, + GOOGLE_DEVICE_URL, + PackedStringArray(["Content-Type: application/x-www-form-urlencoded"]), + CloudHttp.form_encode({ + "client_id": client_id, + "scope": GOOGLE_SCOPES, + }).to_utf8_buffer() + ) + if response.is_empty(): + _fail(http.last_error) + return + var data: Variant = CloudHttp.json_parse(response["body"]) + if int(response["status"]) != 200 or not data is Dictionary: + _fail("Anmeldecode konnte nicht angefordert werden: " + CloudHttp.error_text(data, response)) + return + + var payload: Dictionary = data + var device_code := str(payload.get("device_code", "")) + user_code = str(payload.get("user_code", "")) + verification_url = str(payload.get("verification_url", payload.get("verification_uri", ""))) + if device_code.is_empty() or user_code.is_empty() or verification_url.is_empty(): + _fail("Der Anbieter hat keinen gültigen Anmeldecode geliefert.") + return + + status = "Warte auf Bestätigung im Browser …" + var interval := maxi(5, int(payload.get("interval", 5))) + var deadline := Time.get_ticks_msec() + maxi(60, int(payload.get("expires_in", 600))) * 1000 + var token_url := CloudAuth.GOOGLE_TOKEN_URL + + while Time.get_ticks_msec() < deadline: + if cancelled: + _fail("Anmeldung abgebrochen.") + return + OS.delay_msec(interval * 1000) + if cancelled: + _fail("Anmeldung abgebrochen.") + return + var token_response := http.request( + HTTPClient.METHOD_POST, + token_url, + PackedStringArray(["Content-Type: application/x-www-form-urlencoded"]), + CloudHttp.form_encode({ + "client_id": client_id, + "client_secret": client_secret, + "device_code": device_code, + "grant_type": "urn:ietf:params:oauth:grant-type:device_code", + }).to_utf8_buffer() + ) + if token_response.is_empty(): + _fail(http.last_error) + return + var token_data: Variant = CloudHttp.json_parse(token_response["body"]) + if int(token_response["status"]) == 200 and token_data is Dictionary: + var tokens := CloudAuth.tokens_from_response(token_data) + if str(tokens.get("refresh_token", "")).is_empty(): + _fail( + "Google hat keinen Refresh-Token geliefert. Bitte den " + + "App-Zugriff in den Google-Kontoeinstellungen entfernen " + + "und erneut verbinden." + ) + return + result = tokens + status = "Verbunden." + done = true + return + var token_error := _oauth_error(token_data) + if token_error == "authorization_pending": + continue + if token_error == "slow_down": + interval += 5 + continue + if token_error == "access_denied": + _fail("Die Anmeldung wurde im Browser abgelehnt.") + return + if token_error == "expired_token": + _fail("Der Anmeldecode ist abgelaufen. Bitte erneut verbinden.") + return + _fail("Google-Anmeldung fehlgeschlagen: " + CloudHttp.error_text(token_data, token_response)) + return + + _fail("Zeitüberschreitung bei der Google-Anmeldung. Bitte erneut verbinden.") + + +func run_dropbox_exchange( + app_key: String, + app_secret: String, + code_verifier: String, + code: String +) -> void: + provider = "dropbox" + status = "Tausche Anmeldecode …" + var http := CloudHttp.new() + var params := { + "code": code.strip_edges(), + "grant_type": "authorization_code", + "client_id": app_key, + "code_verifier": code_verifier, + } + if not app_secret.is_empty(): + params["client_secret"] = app_secret + var response := http.request( + HTTPClient.METHOD_POST, + CloudAuth.DROPBOX_TOKEN_URL, + PackedStringArray(["Content-Type: application/x-www-form-urlencoded"]), + CloudHttp.form_encode(params).to_utf8_buffer() + ) + if response.is_empty(): + _fail(http.last_error) + return + var data: Variant = CloudHttp.json_parse(response["body"]) + if int(response["status"]) != 200 or not data is Dictionary: + _fail("Dropbox-Anmeldung fehlgeschlagen: " + CloudHttp.error_text(data, response)) + return + var tokens := CloudAuth.tokens_from_response(data) + if str(tokens.get("refresh_token", "")).is_empty(): + _fail( + "Dropbox hat keinen Refresh-Token geliefert. Bitte den App-Zugriff " + + "in den Dropbox-Einstellungen entfernen und erneut verbinden." + ) + return + tokens["account"] = _dropbox_account(http, str(tokens.get("access_token", ""))) + result = tokens + status = "Verbunden." + done = true + + +func _dropbox_account(http: CloudHttp, access_token: String) -> String: + if access_token.is_empty(): + return "" + var response := http.request( + HTTPClient.METHOD_POST, + DROPBOX_ACCOUNT_URL, + PackedStringArray([ + "Authorization: Bearer " + access_token, + "Content-Type: application/json", + ]), + PackedByteArray() + ) + if response.is_empty() or int(response["status"]) != 200: + return "" + var data: Variant = CloudHttp.json_parse(response["body"]) + if not data is Dictionary: + return "" + var account: Dictionary = data + var email := str(account.get("email", "")) + if not email.is_empty(): + return email + var name: Variant = account.get("name", {}) + if name is Dictionary: + return str((name as Dictionary).get("display_name", "")) + return "" + + +func _oauth_error(data: Variant) -> String: + if data is Dictionary: + return str((data as Dictionary).get("error", "")) + return "" + + +func _fail(message: String) -> void: + error = message + status = message + done = true + + +static func new_verifier() -> String: + var bytes := Crypto.new().generate_random_bytes(32) + return base64url(bytes) + + +static func pkce_challenge(verifier: String) -> String: + var context := HashingContext.new() + context.start(HashingContext.HASH_SHA256) + context.update(verifier.to_utf8_buffer()) + return base64url(context.finish()) + + +static func base64url(bytes: PackedByteArray) -> String: + var encoded := Marshalls.raw_to_base64(bytes) + encoded = encoded.replace("+", "-").replace("/", "_") + return encoded.rstrip("=") + + +static func dropbox_authorize_url(app_key: String, verifier: String) -> String: + return DROPBOX_AUTHORIZE_URL + "?" + CloudHttp.form_encode({ + "client_id": app_key, + "response_type": "code", + "token_access_type": "offline", + "code_challenge": pkce_challenge(verifier), + "code_challenge_method": "S256", + }) diff --git a/rinkplanner/src/core/sync/cloud_oauth_job.gd.uid b/rinkplanner/src/core/sync/cloud_oauth_job.gd.uid new file mode 100644 index 0000000..5458bde --- /dev/null +++ b/rinkplanner/src/core/sync/cloud_oauth_job.gd.uid @@ -0,0 +1 @@ +uid://b33i7cyu0wjtf diff --git a/rinkplanner/src/core/sync/dropbox_store.gd b/rinkplanner/src/core/sync/dropbox_store.gd new file mode 100644 index 0000000..45e7624 --- /dev/null +++ b/rinkplanner/src/core/sync/dropbox_store.gd @@ -0,0 +1,279 @@ +class_name DropboxStore +extends RemoteStore + +## Dropbox backend for the routine sync. +## +## Uses a scoped "App folder" app with offline access (refresh token). All +## paths are relative to the app folder; Rinkplanner never sees the rest of the +## user's Dropbox. Files are uploaded with `files/upload` (mode overwrite) and +## downloaded from `content.dropboxapi.com` – both are single atomic requests. + +const API_URL := "https://api.dropboxapi.com/2" +const CONTENT_URL := "https://content.dropboxapi.com/2" +const LIST_PAGE_LIMIT := 2000 + +var _settings: Dictionary +var _app: Dictionary +var _auth: CloudAuth +var _http := CloudHttp.new() +var _directory := "" +var _folder := "" +var _last_status := 0 + + +func _init(settings: Dictionary, app: Dictionary) -> void: + _settings = settings.duplicate(true) + _app = app.duplicate(true) + _directory = str(_settings.get("directory", "")).strip_edges().trim_prefix("/").trim_suffix("/") + _folder = "" if _directory.is_empty() else "/" + _directory + var tokens := _provider_tokens() + _auth = CloudAuth.new() + _auth.configure( + "dropbox", + str(_app.get("dropbox_app_key", "")), + str(_app.get("dropbox_app_secret", "")), + tokens + ) + + +func open() -> String: + last_error = "" + if str(_app.get("dropbox_app_key", "")).is_empty(): + return SyncAppConfig.missing_hint("dropbox") + if not _directory.is_empty() and _directory.contains("/"): + return "Der Cloud-Ordner darf keine Unterordner enthalten." + last_error = _auth.ensure_access_token() + if not last_error.is_empty(): + return last_error + return _ensure_folder() + + +func list_files() -> Array[Dictionary]: + var files: Array[Dictionary] = [] + var data := _post_json("files/list_folder", { + "path": _folder, + "recursive": false, + "include_deleted": false, + "include_non_downloadable_files": false, + "limit": LIST_PAGE_LIMIT, + }) + if _last_status != 200: + return files + + while true: + var entries: Variant = data.get("entries", []) + if entries is Array: + for raw_entry: Variant in entries: + if not raw_entry is Dictionary: + continue + var entry: Dictionary = raw_entry + if str(entry.get(".tag", "")) != "file": + continue + var name := str(entry.get("name", "")) + if name.is_empty(): + continue + files.append({ + "name": name, + "size": int(entry.get("size", -1)), + "modify": parse_timestamp(str(entry.get("server_modified", ""))), + }) + if not bool(data.get("has_more", false)): + break + data = _post_json("files/list_folder/continue", { + "cursor": str(data.get("cursor", "")), + }) + if _last_status != 200: + break + return files + + +func download(remote_name: String, local_path: String) -> String: + var response := _content("files/download", {"path": _path(remote_name)}) + if _last_status != 200: + return last_error + var payload: PackedByteArray = response.get("body", PackedByteArray()) + var metadata_text := CloudHttp.header(response.get("headers", {}), "dropbox-api-result") + if not metadata_text.is_empty(): + var metadata: Variant = JSON.parse_string(metadata_text) + if metadata is Dictionary and metadata.has("size"): + var expected := int(metadata["size"]) + if expected >= 0 and payload.size() != expected: + return ( + "Download unvollständig: %d von %d Bytes" + % [payload.size(), expected] + ) + var file := FileAccess.open(local_path, FileAccess.WRITE) + if file == null: + return "Lokale Datei nicht schreibbar: %s" % local_path + file.store_buffer(payload) + file.close() + return "" + + +func upload(local_path: String, remote_name: String) -> String: + var file := FileAccess.open(local_path, FileAccess.READ) + if file == null: + return "Lokale Datei nicht lesbar: %s" % local_path + var payload := file.get_buffer(file.get_length()) + file.close() + _content("files/upload", { + "path": _path(remote_name), + "mode": "overwrite", + "autorename": false, + "mute": true, + }, payload) + if _last_status != 200: + return last_error + return "" + + +func delete_file(remote_name: String) -> String: + _post_json("files/delete_v2", {"path": _path(remote_name)}) + if _last_status == 200: + return "" + if _last_status == 409 and last_error.contains("not_found"): + return "" + return last_error if not last_error.is_empty() else "Löschen fehlgeschlagen." + + +func rename(from_name: String, to_name: String) -> String: + _post_json("files/move_v2", { + "from_path": _path(from_name), + "to_path": _path(to_name), + "autorename": false, + }) + if _last_status == 200: + return "" + return last_error if not last_error.is_empty() else "Umbenennen fehlgeschlagen." + + +func close() -> void: + pass + + +func _ensure_folder() -> String: + if _folder.is_empty(): + return "" + _post_json("files/get_metadata", {"path": _folder}) + if _last_status == 200: + return "" + if _last_status != 409: + return last_error if not last_error.is_empty() else "Cloud-Ordner nicht erreichbar." + _post_json("files/create_folder_v2", {"path": _folder, "autorename": false}) + if _last_status == 200 or _last_status == 409: + return "" + return last_error if not last_error.is_empty() else "Cloud-Ordner konnte nicht angelegt werden." + + +func _path(name: String) -> String: + return remote_path(_folder, name) + + +func _provider_tokens() -> Dictionary: + var all_tokens: Variant = _settings.get("tokens", {}) + if all_tokens is Dictionary: + var entry: Variant = (all_tokens as Dictionary).get("dropbox", {}) + if entry is Dictionary: + return (entry as Dictionary).duplicate(true) + return {} + + +func _headers() -> PackedStringArray: + return PackedStringArray([ + "Authorization: Bearer " + _auth.access_token, + ]) + + +func _post_json(endpoint: String, payload: Dictionary) -> Dictionary: + var body := CloudHttp.json_stringify(payload).to_utf8_buffer() + var headers := _headers() + headers.append("Content-Type: application/json") + for attempt: int in range(2): + var response := _http.request( + HTTPClient.METHOD_POST, + API_URL + "/" + endpoint, + headers, + body + ) + if response.is_empty(): + _last_status = 0 + last_error = _http.last_error + return {} + _last_status = int(response["status"]) + var data: Variant = CloudHttp.json_parse(response["body"]) + if _last_status == 401 and attempt == 0: + var refresh_error := _refresh_token() + if not refresh_error.is_empty(): + last_error = refresh_error + return {} + continue + if _last_status >= 200 and _last_status < 300: + last_error = "" + return data if data is Dictionary else {} + last_error = CloudHttp.error_text(data, response) + return {} + return {} + + +func _content(endpoint: String, arg: Dictionary, body: PackedByteArray = PackedByteArray()) -> Dictionary: + for attempt: int in range(2): + var headers := content_headers(_auth.access_token, arg) + var response := _http.request( + HTTPClient.METHOD_POST, + CONTENT_URL + "/" + endpoint, + headers, + body, + CloudHttp.TRANSFER_TIMEOUT_MSEC + ) + if response.is_empty(): + _last_status = 0 + last_error = _http.last_error + return {} + _last_status = int(response["status"]) + if _last_status == 401 and attempt == 0: + var refresh_error := _refresh_token() + if not refresh_error.is_empty(): + last_error = refresh_error + return {} + continue + if _last_status >= 200 and _last_status < 300: + last_error = "" + return response + var data: Variant = CloudHttp.json_parse(response["body"]) + last_error = CloudHttp.error_text(data, response) + return {} + return {} + + +func _refresh_token() -> String: + _auth.access_token = "" + return _auth.ensure_access_token() + + +## Content-API headers exactly once. Dropbox rejects duplicate Content-Type +## headers, so the auth helper must not add one. +static func content_headers(access_token: String, arg: Dictionary) -> PackedStringArray: + return PackedStringArray([ + "Authorization: Bearer " + access_token, + "Dropbox-API-Arg: " + CloudHttp.json_stringify_ascii(arg), + "Content-Type: application/octet-stream", + ]) + + +static func remote_path(folder: String, name: String) -> String: + var base := folder.strip_edges() + if base.is_empty() or base == "/": + return "/" + name + if not base.begins_with("/"): + base = "/" + base + return base.trim_suffix("/") + "/" + name + + +static func parse_timestamp(value: String) -> int: + # "2026-11-09T12:34:56Z" or with fractional seconds. + var text := value.strip_edges().trim_suffix("Z") + if text.contains("."): + text = text.split(".", true, 1)[0] + if text.length() < 19: + return -1 + return int(Time.get_unix_time_from_datetime_string(text)) diff --git a/rinkplanner/src/core/sync/dropbox_store.gd.uid b/rinkplanner/src/core/sync/dropbox_store.gd.uid new file mode 100644 index 0000000..46574b2 --- /dev/null +++ b/rinkplanner/src/core/sync/dropbox_store.gd.uid @@ -0,0 +1 @@ +uid://kjceh3wa2e22 diff --git a/rinkplanner/src/core/sync/ftp_client.gd b/rinkplanner/src/core/sync/ftp_client.gd deleted file mode 100644 index c9f02b1..0000000 --- a/rinkplanner/src/core/sync/ftp_client.gd +++ /dev/null @@ -1,514 +0,0 @@ -class_name FtpClient -extends RefCounted - -## Minimal blocking FTP/FTPS client for the manual routine sync. -## -## Runs on a worker thread, so it never touches the scene tree. All methods -## return an error string ("" means success); [member last_error] carries the -## reason for value-returning helpers. -## -## Supported: USER/PASS, AUTH TLS + PROT P (explicit FTPS), EPSV/PASV, -## MLSD, SIZE, MDTM, RETR, STOR, DELE, MKD, CWD, PWD, RNFR/RNTO. - -enum Encryption { - NONE, - EXPLICIT_TLS, -} - -const DEFAULT_TIMEOUT_MSEC := 15000 -const TRANSFER_TIMEOUT_MSEC := 120000 -const POLL_DELAY_MSEC := 5 - -var last_error: String = "" - -var _tcp: StreamPeerTCP -var _peer: StreamPeer -var _host: String = "" -var _port: int = 21 -var _timeout_msec: int = DEFAULT_TIMEOUT_MSEC -var _encryption: Encryption = Encryption.NONE -var _tls_options: TLSOptions -var _buffer: String = "" -var _expected_size: int = -1 - - -func connect_to( - host: String, - port: int = 21, - encryption: Encryption = Encryption.NONE, - verify_certificate: bool = true -) -> String: - last_error = "" - _host = host - _port = port - _encryption = encryption - _tls_options = ( - TLSOptions.client() - if verify_certificate - else TLSOptions.client_unsafe() - ) - - _tcp = StreamPeerTCP.new() - var err := _tcp.connect_to_host(host, port) - if err != OK: - return "Verbindung zu %s:%d fehlgeschlagen (Fehler %d)" % [host, port, err] - - if not _wait_for_tcp(_tcp, _timeout_msec): - close() - return "Zeitüberschreitung beim Verbindungsaufbau zu %s:%d" % [host, port] - - _peer = _tcp - var reply := _read_reply() - if reply.is_empty() or int(reply["code"]) / 100 != 2: - close() - return "Server hat die Verbindung nicht bestätigt: %s" % _reply_text(reply) - - if encryption == Encryption.EXPLICIT_TLS: - reply = _command("AUTH TLS") - if reply.get("code", 0) != 234: - close() - return "Server lehnt FTPS ab: %s" % _reply_text(reply) - var tls := StreamPeerTLS.new() - var tls_err := tls.connect_to_stream(_tcp, host, _tls_options) - if tls_err != OK: - close() - return "TLS-Handshake konnte nicht gestartet werden (Fehler %d)" % tls_err - var deadline := Time.get_ticks_msec() + _timeout_msec - while tls.get_status() == StreamPeerTLS.STATUS_HANDSHAKING: - if Time.get_ticks_msec() > deadline: - close() - return "TLS-Handshake: Zeitüberschreitung" - tls.poll() - OS.delay_msec(POLL_DELAY_MSEC) - if tls.get_status() != StreamPeerTLS.STATUS_CONNECTED: - var status := tls.get_status() - close() - return ( - "TLS-Handshake fehlgeschlagen (Status %d). " - + "Wenn der Server ein ungültiges Zertifikat nutzt, " - + "die Zertifikatsprüfung in den Sync-Einstellungen abschalten." - ) % status - _peer = tls - - return "" - - -func login(user: String, password: String) -> String: - var reply := _command("USER " + user) - if reply.get("code", 0) == 331: - reply = _command("PASS " + password) - if reply.get("code", 0) != 230: - return "Login fehlgeschlagen: %s" % _reply_text(reply) - - if _encryption == Encryption.EXPLICIT_TLS: - reply = _command("PBSZ 0") - if reply.get("code", 0) != 200: - return "PBSZ fehlgeschlagen: %s" % _reply_text(reply) - reply = _command("PROT P") - if reply.get("code", 0) != 200: - return "PROT P fehlgeschlagen: %s" % _reply_text(reply) - - reply = _command("TYPE I") - if reply.get("code", 0) != 200: - return "Binärmodus nicht möglich: %s" % _reply_text(reply) - return "" - - -func pwd() -> String: - var reply := _command("PWD") - if reply.get("code", 0) != 257: - last_error = _reply_text(reply) - return "" - var text: String = reply.get("text", "") - var start := text.find('"') - var end := text.find('"', start + 1) - if start < 0 or end < 0: - return "" - return text.substr(start + 1, end - start - 1) - - -func change_dir(path: String) -> String: - var reply := _command("CWD " + path) - if reply.get("code", 0) != 250: - return "Verzeichniswechsel fehlgeschlagen: %s" % _reply_text(reply) - return "" - - -func make_dir(path: String) -> String: - var reply := _command("MKD " + path) - if reply.get("code", 0) in [250, 257]: - return "" - return "Ordner konnte nicht angelegt werden: %s" % _reply_text(reply) - - -## Returns [name, size, modify] entries with type "file" only. -func list_files() -> Array[Dictionary]: - var entries: Array[Dictionary] = [] - var socket := _open_data_socket() - if socket == null: - return entries - - var reply := _command("MLSD") - if reply.get("code", 0) not in [125, 150]: - close_data_connection(socket) - last_error = "Verzeichnisliste nicht möglich: %s" % _reply_text(reply) - return entries - - var data_peer := _secure_data_peer(socket) - if data_peer == null: - _read_reply() - return entries - var payload := _read_all(data_peer, Time.get_ticks_msec() + TRANSFER_TIMEOUT_MSEC) - close_data_connection(data_peer) - reply = _read_reply() - if reply.get("code", 0) != 226: - last_error = "Übertragung der Liste unvollständig: %s" % _reply_text(reply) - return entries - - for raw_line: String in payload.get_string_from_utf8().split("\n"): - var line := raw_line.strip_edges() - if line.is_empty() or not line.contains(";"): - continue - var parts := line.split(" ", false, 1) - if parts.size() < 2: - continue - var facts := parts[0].split(";", false) - var name := parts[1] - var info: Dictionary = {"name": name, "size": -1, "modify": -1} - for fact: String in facts: - var pair := fact.split("=", true, 1) - if pair.size() != 2: - continue - match pair[0].to_lower(): - "type": - info["type"] = pair[1].to_lower() - "size": - info["size"] = int(pair[1]) - "modify": - info["modify"] = parse_mdtm(pair[1]) - if info.get("type", "") != "file": - continue - if name in [".", ".."]: - continue - entries.append(info) - return entries - - -func file_size(name: String) -> int: - var reply := _command("SIZE " + name) - if reply.get("code", 0) != 213: - last_error = _reply_text(reply) - return -1 - var value := str(reply.get("text", "")).strip_edges().split(" ", false, 1) - return int(value[-1]) if value.size() > 0 else -1 - - -func download(remote_name: String, local_path: String) -> String: - _expected_size = file_size(remote_name) - var socket := _open_data_socket() - if socket == null: - return "Datenverbindung fehlgeschlagen: " + last_error - - var reply := _command("RETR " + remote_name) - if reply.get("code", 0) not in [125, 150]: - close_data_connection(socket) - return "Download abgelehnt: %s" % _reply_text(reply) - - var data_peer := _secure_data_peer(socket) - if data_peer == null: - _read_reply() - return last_error - var payload := _read_all( - data_peer, - Time.get_ticks_msec() + TRANSFER_TIMEOUT_MSEC, - _expected_size - ) - close_data_connection(data_peer) - reply = _read_reply() - if reply.get("code", 0) != 226: - return "Download unvollständig: %s" % _reply_text(reply) - if _expected_size >= 0 and payload.size() != _expected_size: - return ( - "Download unvollständig: %d von %d Bytes" - % [payload.size(), _expected_size] - ) - - var file := FileAccess.open(local_path, FileAccess.WRITE) - if file == null: - return "Lokale Datei nicht schreibbar: %s" % local_path - file.store_buffer(payload) - file.close() - return "" - - -func upload(local_path: String, remote_name: String) -> String: - var file := FileAccess.open(local_path, FileAccess.READ) - if file == null: - return "Lokale Datei nicht lesbar: %s" % local_path - var payload := file.get_buffer(file.get_length()) - file.close() - - var socket := _open_data_socket() - if socket == null: - return "Datenverbindung fehlgeschlagen: " + last_error - - var reply := _command("STOR " + remote_name) - if reply.get("code", 0) not in [125, 150]: - close_data_connection(socket) - return "Upload abgelehnt: %s" % _reply_text(reply) - - var data_peer := _secure_data_peer(socket) - if data_peer == null: - _read_reply() - return last_error - var err := data_peer.put_data(payload) - close_data_connection(data_peer) - if err != OK: - return "Upload abgebrochen (Fehler %d)" % err - - reply = _read_reply() - if reply.get("code", 0) != 226: - return "Upload unvollständig: %s" % _reply_text(reply) - return "" - - -func delete_file(remote_name: String) -> String: - var reply := _command("DELE " + remote_name) - if reply.get("code", 0) != 250: - return "Löschen abgelehnt: %s" % _reply_text(reply) - return "" - - -func rename(from_name: String, to_name: String) -> String: - var reply := _command("RNFR " + from_name) - if reply.get("code", 0) != 350: - return "Umbenennen abgelehnt: %s" % _reply_text(reply) - reply = _command("RNTO " + to_name) - if reply.get("code", 0) != 250: - return "Umbenennen fehlgeschlagen: %s" % _reply_text(reply) - return "" - - -func close() -> void: - if _peer is StreamPeerTLS: - (_peer as StreamPeerTLS).disconnect_from_stream() - _peer = null - if _tcp != null: - _tcp.disconnect_from_host() - _tcp = null - _buffer = "" - - -# --- protocol helpers -------------------------------------------------------- - -static func parse_mdtm(value: String) -> int: - # YYYYMMDDHHMMSS[.sss], UTC. - var digits := value.strip_edges() - if digits.contains("."): - digits = digits.split(".", true, 1)[0] - if digits.length() < 14 or not digits.is_valid_int(): - return -1 - var iso := "%s-%s-%sT%s:%s:%s" % [ - digits.substr(0, 4), - digits.substr(4, 2), - digits.substr(6, 2), - digits.substr(8, 2), - digits.substr(10, 2), - digits.substr(12, 2), - ] - return int(Time.get_unix_time_from_datetime_string(iso)) - - -static func parse_pasv(reply: String) -> Dictionary: - # 227 Entering Passive Mode (h1,h2,h3,h4,p1,p2) - var start := reply.find("(") - var end := reply.find(")") - if start < 0 or end <= start: - return {} - var numbers := reply.substr(start + 1, end - start - 1).split(",", false) - if numbers.size() != 6: - return {} - var host := "%s.%s.%s.%s" % [numbers[0], numbers[1], numbers[2], numbers[3]] - var port := int(numbers[4]) * 256 + int(numbers[5]) - return {"host": host, "port": port} - - -static func parse_epsv(reply: String) -> int: - # 229 Entering Extended Passive Mode (|||port|) - var start := reply.find("(") - var end := reply.find(")", start + 1) - if start < 0 or end <= start: - return -1 - var body := reply.substr(start + 1, end - start - 1) - var parts := body.split("|", true) - for part: String in parts: - if part.is_valid_int(): - return int(part) - return -1 - - -# --- transport --------------------------------------------------------------- - -func _command(command: String) -> Dictionary: - if _peer == null: - last_error = "Nicht verbunden" - return {} - var payload := (command + "\r\n").to_utf8_buffer() - var err := _peer.put_data(payload) - if err != OK: - last_error = "Senden fehlgeschlagen (Fehler %d)" % err - return {} - return _read_reply() - - -func _read_reply() -> Dictionary: - var deadline := Time.get_ticks_msec() + _timeout_msec - var lines := PackedStringArray() - var code := -1 - while true: - var line := _read_line(deadline) - if line.is_empty(): - last_error = "Zeitüberschreitung beim Warten auf den Server" - return {} - lines.append(line) - if line.length() >= 4 and line[3] == " ": - code = int(line.substr(0, 3)) - break - if line.length() == 3: - code = int(line) - break - return {"code": code, "text": "\n".join(lines)} - - -func _read_line(deadline: int) -> String: - while true: - var index := _buffer.find("\n") - if index >= 0: - var line := _buffer.substr(0, index).trim_suffix("\r") - _buffer = _buffer.substr(index + 1) - return line - if Time.get_ticks_msec() > deadline: - return "" - if _peer is StreamPeerTLS: - (_peer as StreamPeerTLS).poll() - var available := _peer.get_available_bytes() - if available > 0: - var chunk := _peer.get_data(available) - if chunk[0] == OK: - _buffer += (chunk[1] as PackedByteArray).get_string_from_utf8() - continue - if not _is_connected(_peer): - return "" - OS.delay_msec(POLL_DELAY_MSEC) - return "" - - -func _open_data_socket() -> StreamPeerTCP: - last_error = "" - var reply := _command("EPSV") - var host := _host - var port := parse_epsv(str(reply.get("text", ""))) - if reply.get("code", 0) != 229 or port <= 0: - reply = _command("PASV") - var parsed := parse_pasv(str(reply.get("text", ""))) - if reply.get("code", 0) != 227 or parsed.is_empty(): - last_error = "Passiver Modus nicht möglich: %s" % _reply_text(reply) - return null - host = parsed["host"] - port = parsed["port"] - - var tcp := StreamPeerTCP.new() - var err := tcp.connect_to_host(host, port) - if err != OK: - last_error = "Datenverbindung fehlgeschlagen (Fehler %d)" % err - return null - if not _wait_for_tcp(tcp, _timeout_msec): - tcp.disconnect_from_host() - last_error = "Zeitüberschreitung bei der Datenverbindung" - return null - return tcp - - -## Wraps the data socket in TLS for explicit FTPS. Called after the server -## accepted the transfer command, which is when the handshake actually starts. -func _secure_data_peer(socket: StreamPeerTCP) -> StreamPeer: - if _encryption != Encryption.EXPLICIT_TLS: - return socket - - var tls := StreamPeerTLS.new() - var err := tls.connect_to_stream(socket, _host, _tls_options) - if err != OK: - socket.disconnect_from_host() - last_error = "TLS der Datenverbindung fehlgeschlagen (Fehler %d)" % err - return null - - var deadline := Time.get_ticks_msec() + _timeout_msec - while tls.get_status() == StreamPeerTLS.STATUS_HANDSHAKING: - if Time.get_ticks_msec() > deadline: - tls.disconnect_from_stream() - last_error = "TLS-Handshake der Datenverbindung: Zeitüberschreitung" - return null - tls.poll() - OS.delay_msec(POLL_DELAY_MSEC) - if tls.get_status() != StreamPeerTLS.STATUS_CONNECTED: - tls.disconnect_from_stream() - last_error = "TLS-Handshake der Datenverbindung fehlgeschlagen (Status %d)" % tls.get_status() - return null - return tls - - -func _read_all(peer: StreamPeer, deadline: int, expected_size: int = -1) -> PackedByteArray: - var payload := PackedByteArray() - while true: - if peer is StreamPeerTLS: - (peer as StreamPeerTLS).poll() - if _is_connected(peer): - var available := peer.get_available_bytes() - if available > 0: - var chunk := peer.get_data(available) - if chunk[0] == OK: - payload.append_array(chunk[1]) - continue - if expected_size >= 0: - if payload.size() >= expected_size: - break - if not _is_connected(peer): - break - elif not _is_connected(peer): - break - if Time.get_ticks_msec() > deadline: - last_error = "Zeitüberschreitung bei der Datenübertragung" - break - OS.delay_msec(POLL_DELAY_MSEC) - return payload - - -func close_data_connection(peer: StreamPeer) -> void: - if peer == null: - return - if peer is StreamPeerTLS: - (peer as StreamPeerTLS).disconnect_from_stream() - elif peer is StreamPeerTCP: - (peer as StreamPeerTCP).disconnect_from_host() - - -func _wait_for_tcp(tcp: StreamPeerTCP, timeout_msec: int) -> bool: - var deadline := Time.get_ticks_msec() + timeout_msec - while tcp.get_status() == StreamPeerTCP.STATUS_CONNECTING: - if Time.get_ticks_msec() > deadline: - return false - tcp.poll() - OS.delay_msec(POLL_DELAY_MSEC) - return tcp.get_status() == StreamPeerTCP.STATUS_CONNECTED - - -func _is_connected(peer: StreamPeer) -> bool: - if peer is StreamPeerTLS: - return (peer as StreamPeerTLS).get_status() == StreamPeerTLS.STATUS_CONNECTED - return (peer as StreamPeerTCP).get_status() == StreamPeerTCP.STATUS_CONNECTED - - -func _reply_text(reply: Dictionary) -> String: - if reply.is_empty(): - return last_error - return str(reply.get("text", "")).strip_edges().replace("\n", " ") diff --git a/rinkplanner/src/core/sync/ftp_client.gd.uid b/rinkplanner/src/core/sync/ftp_client.gd.uid deleted file mode 100644 index bdd160d..0000000 --- a/rinkplanner/src/core/sync/ftp_client.gd.uid +++ /dev/null @@ -1 +0,0 @@ -uid://3n477aydpya3 diff --git a/rinkplanner/src/core/sync/google_drive_store.gd b/rinkplanner/src/core/sync/google_drive_store.gd new file mode 100644 index 0000000..305c927 --- /dev/null +++ b/rinkplanner/src/core/sync/google_drive_store.gd @@ -0,0 +1,409 @@ +class_name GoogleDriveStore +extends RemoteStore + +## Google Drive backend for the routine sync. +## +## The app uses the non-sensitive `drive.file` scope: it can only see and +## change files that Rinkplanner itself created. Everything lives in a single +## folder ("Rinkplanner" by default) inside the user's own My Drive. + +const API_URL := "https://www.googleapis.com/drive/v3" +const UPLOAD_URL := "https://www.googleapis.com/upload/drive/v3" +const FOLDER_MIME := "application/vnd.google-apps.folder" +const LIST_FIELDS := "nextPageToken,files(id,name,mimeType,modifiedTime,size)" +const FILE_FIELDS := "id,name,modifiedTime,size" + +var _settings: Dictionary +var _app: Dictionary +var _auth: CloudAuth +var _http := CloudHttp.new() +var _directory := "" +var _folder_id := "root" +var _files: Dictionary = {} +var _last_status := 0 +var _lookup_error := "" + + +func _init(settings: Dictionary, app: Dictionary) -> void: + _settings = settings.duplicate(true) + _app = app.duplicate(true) + _directory = str(_settings.get("directory", "")).strip_edges().trim_prefix("/").trim_suffix("/") + var tokens := _provider_tokens() + _auth = CloudAuth.new() + _auth.configure( + "google_drive", + str(_app.get("google_client_id", "")), + str(_app.get("google_client_secret", "")), + tokens + ) + + +func open() -> String: + last_error = "" + if str(_app.get("google_client_id", "")).is_empty(): + return SyncAppConfig.missing_hint("google_drive") + if _directory.is_empty(): + # Never mirror into My Drive root: that would expose unrelated files. + _directory = "Rinkplanner" + if _directory.contains("/"): + return "Der Cloud-Ordner darf keine Unterordner enthalten." + last_error = _auth.ensure_access_token() + if not last_error.is_empty(): + return last_error + return _ensure_folder() + + +func list_files() -> Array[Dictionary]: + var files: Array[Dictionary] = [] + _files.clear() + var page_token := "" + while true: + var query := "'%s' in parents and trashed = false" % escape_query(_folder_id) + var url := ( + API_URL + + "/files?q=" + query.uri_encode() + + "&fields=" + LIST_FIELDS.uri_encode() + + "&pageSize=1000" + ) + if not page_token.is_empty(): + url += "&pageToken=" + page_token.uri_encode() + var data := _get_json(url) + if _last_status != 200: + return files + var entries: Variant = data.get("files", []) + if entries is Array: + for raw_entry: Variant in entries: + if not raw_entry is Dictionary: + continue + var entry: Dictionary = raw_entry + if str(entry.get("mimeType", "")) == FOLDER_MIME: + continue + var name := str(entry.get("name", "")) + if name.is_empty(): + continue + var info := { + "name": name, + "size": _to_int(entry.get("size", -1)), + "modify": parse_timestamp(str(entry.get("modifiedTime", ""))), + } + files.append(info) + _files[name] = { + "id": str(entry.get("id", "")), + "size": info["size"], + "modify": info["modify"], + } + page_token = str(data.get("nextPageToken", "")) + if page_token.is_empty(): + break + return files + + +func download(remote_name: String, local_path: String) -> String: + var file_id := _lookup_id(remote_name) + if not _lookup_error.is_empty(): + return _lookup_error + if file_id.is_empty(): + return "Datei nicht in Google Drive gefunden: %s" % remote_name + var response := _request( + HTTPClient.METHOD_GET, + API_URL + "/files/" + file_id.uri_encode() + "?alt=media", + PackedStringArray(), + PackedByteArray(), + CloudHttp.TRANSFER_TIMEOUT_MSEC + ) + if response.is_empty(): + return _http.last_error + _last_status = int(response["status"]) + if _last_status != 200: + var data: Variant = CloudHttp.json_parse(response["body"]) + last_error = CloudHttp.error_text(data, response) + return last_error + var payload: PackedByteArray = response["body"] + var expected := -1 + if _files.has(remote_name): + expected = int((_files[remote_name] as Dictionary).get("size", -1)) + if expected >= 0 and payload.size() != expected: + return "Download unvollständig: %d von %d Bytes" % [payload.size(), expected] + var file := FileAccess.open(local_path, FileAccess.WRITE) + if file == null: + return "Lokale Datei nicht schreibbar: %s" % local_path + file.store_buffer(payload) + file.close() + return "" + + +func upload(local_path: String, remote_name: String) -> String: + var file := FileAccess.open(local_path, FileAccess.READ) + if file == null: + return "Lokale Datei nicht lesbar: %s" % local_path + var payload := file.get_buffer(file.get_length()) + file.close() + + var file_id := _lookup_id(remote_name) + if not _lookup_error.is_empty(): + return _lookup_error + var metadata := {"name": remote_name} + if file_id.is_empty(): + metadata["parents"] = [_folder_id] + var multipart := _multipart_body(metadata, payload) + var url := ( + UPLOAD_URL + + "/files" + + ("" if file_id.is_empty() else "/" + file_id.uri_encode()) + + "?uploadType=multipart&fields=" + FILE_FIELDS.uri_encode() + ) + var method := ( + HTTPClient.METHOD_POST if file_id.is_empty() else HTTPClient.METHOD_PATCH + ) + var response := _request( + method, + url, + PackedStringArray(["Content-Type: " + str(multipart["content_type"])]), + multipart["body"], + CloudHttp.TRANSFER_TIMEOUT_MSEC + ) + if response.is_empty(): + return _http.last_error + _last_status = int(response["status"]) + var data: Variant = CloudHttp.json_parse(response["body"]) + if _last_status < 200 or _last_status >= 300 or not data is Dictionary: + last_error = CloudHttp.error_text(data, response) + return last_error + _cache_file(data) + return "" + + +func delete_file(remote_name: String) -> String: + var file_id := _lookup_id(remote_name) + if not _lookup_error.is_empty(): + return _lookup_error + if file_id.is_empty(): + return "" + var response := _request( + HTTPClient.METHOD_DELETE, + API_URL + "/files/" + file_id.uri_encode(), + PackedStringArray(), + PackedByteArray() + ) + if response.is_empty(): + return _http.last_error + _last_status = int(response["status"]) + if _last_status == 200 or _last_status == 204 or _last_status == 404: + _files.erase(remote_name) + return "" + var data: Variant = CloudHttp.json_parse(response["body"]) + last_error = CloudHttp.error_text(data, response) + return last_error + + +func rename(from_name: String, to_name: String) -> String: + var file_id := _lookup_id(from_name) + if not _lookup_error.is_empty(): + return _lookup_error + if file_id.is_empty(): + return "Datei nicht in Google Drive gefunden: %s" % from_name + var response := _send_json( + HTTPClient.METHOD_PATCH, + API_URL + "/files/" + file_id.uri_encode() + "?fields=" + FILE_FIELDS.uri_encode(), + {"name": to_name} + ) + if response.is_empty(): + return _http.last_error + _last_status = int(response["status"]) + var data: Variant = CloudHttp.json_parse(response["body"]) + if _last_status < 200 or _last_status >= 300 or not data is Dictionary: + last_error = CloudHttp.error_text(data, response) + return last_error + _files.erase(from_name) + _cache_file(data) + return "" + + +func close() -> void: + pass + + +func _ensure_folder() -> String: + var query := ( + "name = '%s' and mimeType = '%s' and 'root' in parents and trashed = false" + % [escape_query(_directory), FOLDER_MIME] + ) + var url := ( + API_URL + + "/files?q=" + query.uri_encode() + + "&fields=" + "files(id,name)".uri_encode() + + "&pageSize=10" + ) + var data := _get_json(url) + if _last_status != 200: + return last_error + var entries: Variant = data.get("files", []) + if entries is Array and not entries.is_empty(): + _folder_id = str((entries[0] as Dictionary).get("id", "root")) + return "" + var create := _send_json(HTTPClient.METHOD_POST, API_URL + "/files?fields=" + "id,name".uri_encode(), { + "name": _directory, + "mimeType": FOLDER_MIME, + "parents": ["root"], + }) + if _last_status < 200 or _last_status >= 300: + return last_error + _folder_id = str(create.get("id", "")) + if _folder_id.is_empty(): + return "Google Drive hat keinen Ordner angelegt." + return "" + + +func _lookup_id(name: String) -> String: + _lookup_error = "" + if _files.has(name): + return str((_files[name] as Dictionary).get("id", "")) + var query := ( + "name = '%s' and '%s' in parents and trashed = false" + % [escape_query(name), escape_query(_folder_id)] + ) + var url := ( + API_URL + + "/files?q=" + query.uri_encode() + + "&fields=" + FILE_FIELDS.uri_encode() + + "&pageSize=10" + ) + var data := _get_json(url) + if _last_status != 200: + _lookup_error = last_error + return "" + var entries: Variant = data.get("files", []) + if not entries is Array or entries.is_empty(): + return "" + var entry: Dictionary = entries[0] + _cache_file(entry) + return str(entry.get("id", "")) + + +func _cache_file(data: Dictionary) -> void: + var name := str(data.get("name", "")) + if name.is_empty(): + return + _files[name] = { + "id": str(data.get("id", "")), + "size": _to_int(data.get("size", -1)), + "modify": parse_timestamp(str(data.get("modifiedTime", ""))), + } + + +func _provider_tokens() -> Dictionary: + var all_tokens: Variant = _settings.get("tokens", {}) + if all_tokens is Dictionary: + var entry: Variant = (all_tokens as Dictionary).get("google_drive", {}) + if entry is Dictionary: + return (entry as Dictionary).duplicate(true) + return {} + + +func _request( + method: int, + url: String, + extra_headers: PackedStringArray, + body: PackedByteArray, + timeout_msec: int = CloudHttp.DEFAULT_TIMEOUT_MSEC +) -> Dictionary: + var response := _http.request(method, url, _headers(extra_headers), body, timeout_msec) + if response.is_empty(): + return {} + if int(response.get("status", 0)) == 401: + _auth.access_token = "" + var refresh_error := _auth.ensure_access_token() + if not refresh_error.is_empty(): + last_error = refresh_error + return {} + response = _http.request(method, url, _headers(extra_headers), body, timeout_msec) + return response + + +func _headers(extra: PackedStringArray) -> PackedStringArray: + var headers := PackedStringArray(extra) + headers.append("Authorization: Bearer " + _auth.access_token) + return headers + + +func _get_json(url: String) -> Dictionary: + var response := _request( + HTTPClient.METHOD_GET, + url, + PackedStringArray(), + PackedByteArray() + ) + if response.is_empty(): + _last_status = 0 + last_error = _http.last_error + return {} + _last_status = int(response["status"]) + var data: Variant = CloudHttp.json_parse(response["body"]) + if _last_status < 200 or _last_status >= 300: + last_error = CloudHttp.error_text(data, response) + return {} + last_error = "" + return data if data is Dictionary else {} + + +func _send_json(method: int, url: String, payload: Dictionary) -> Dictionary: + var body := CloudHttp.json_stringify(payload).to_utf8_buffer() + var response := _request( + method, + url, + PackedStringArray(["Content-Type: application/json; charset=UTF-8"]), + body + ) + if response.is_empty(): + _last_status = 0 + last_error = _http.last_error + return {} + _last_status = int(response["status"]) + var data: Variant = CloudHttp.json_parse(response["body"]) + if _last_status < 200 or _last_status >= 300: + last_error = CloudHttp.error_text(data, response) + return {} + last_error = "" + return data if data is Dictionary else {} + + +func _multipart_body(metadata: Dictionary, payload: PackedByteArray) -> Dictionary: + var boundary := "rinkplanner-" + str(Time.get_ticks_usec()) + var prefix := ( + "--%s\r\n" + + "Content-Type: application/json; charset=UTF-8\r\n\r\n" + + "%s\r\n" + + "--%s\r\n" + + "Content-Type: application/octet-stream\r\n\r\n" + ) % [boundary, CloudHttp.json_stringify(metadata), boundary] + var suffix := "\r\n--%s--\r\n" % boundary + var body := PackedByteArray() + body.append_array(prefix.to_utf8_buffer()) + body.append_array(payload) + body.append_array(suffix.to_utf8_buffer()) + return { + "body": body, + "content_type": "multipart/related; boundary=" + boundary, + } + + +static func escape_query(value: String) -> String: + return value.replace("\\", "\\\\").replace("'", "\\'") + + +static func parse_timestamp(value: String) -> int: + var text := value.strip_edges().trim_suffix("Z") + if text.contains("."): + text = text.split(".", true, 1)[0] + if text.length() < 19: + return -1 + return int(Time.get_unix_time_from_datetime_string(text)) + + +static func _to_int(value: Variant) -> int: + if value == null: + return -1 + if value is int or value is float: + return int(value) + var text := str(value).strip_edges() + return int(text) if text.is_valid_int() else -1 diff --git a/rinkplanner/src/core/sync/google_drive_store.gd.uid b/rinkplanner/src/core/sync/google_drive_store.gd.uid new file mode 100644 index 0000000..abbd8b8 --- /dev/null +++ b/rinkplanner/src/core/sync/google_drive_store.gd.uid @@ -0,0 +1 @@ +uid://drj84omv865yc diff --git a/rinkplanner/src/core/sync/remote_store.gd b/rinkplanner/src/core/sync/remote_store.gd new file mode 100644 index 0000000..b8fbaa2 --- /dev/null +++ b/rinkplanner/src/core/sync/remote_store.gd @@ -0,0 +1,60 @@ +class_name RemoteStore +extends RefCounted + +## Common interface of the cloud backends. [RoutineSync] only talks to this +## class, so the comparison rules stay independent of Dropbox/Google details. + +var last_error: String = "" + + +static func create( + provider: String, + settings: Dictionary, + app: Dictionary +) -> RemoteStore: + match provider: + "dropbox": + return DropboxStore.new(settings, app) + "google_drive": + return GoogleDriveStore.new(settings, app) + return null + + +static func provider_label(provider: String) -> String: + match provider: + "dropbox": + return "Dropbox" + "google_drive": + return "Google Drive" + return "Cloud" + + +## Authenticates, resolves the target folder and prepares the backend. +func open() -> String: + return "" + + +## Returns [{name, size, modify}] for all files in the target folder. Folders +## and unrelated files are filtered by [RoutineSync]. +func list_files() -> Array[Dictionary]: + return [] + + +func download(_remote_name: String, _local_path: String) -> String: + return "Download ist für diesen Anbieter nicht implementiert." + + +func upload(_local_path: String, _remote_name: String) -> String: + return "Upload ist für diesen Anbieter nicht implementiert." + + +func delete_file(_remote_name: String) -> String: + return "Löschen ist für diesen Anbieter nicht implementiert." + + +func rename(_from_name: String, _to_name: String) -> String: + return "Umbenennen ist für diesen Anbieter nicht implementiert." + + +func close() -> void: + pass diff --git a/rinkplanner/src/core/sync/remote_store.gd.uid b/rinkplanner/src/core/sync/remote_store.gd.uid new file mode 100644 index 0000000..eef5b57 --- /dev/null +++ b/rinkplanner/src/core/sync/remote_store.gd.uid @@ -0,0 +1 @@ +uid://cbvjyx473huoq diff --git a/rinkplanner/src/core/sync/routine_sync.gd b/rinkplanner/src/core/sync/routine_sync.gd index 982e565..fdb14d7 100644 --- a/rinkplanner/src/core/sync/routine_sync.gd +++ b/rinkplanner/src/core/sync/routine_sync.gd @@ -1,16 +1,19 @@ class_name RoutineSync extends RefCounted -## Executes the manual sync between `user://routines` and an FTP directory. -## Intended to run on a worker thread: it only reports through [member result], -## [member error] and [member progress], never through signals. +## Executes the manual sync between `user://routines` and the user's cloud +## folder (Google Drive or Dropbox). Intended to run on a worker thread: it only +## reports through [member result], [member error] and [member progress], never +## through signals. +## +## The cloud account belongs to the user. Rinkplanner never talks to a shared +## server and never sees credentials of other users. const LOCAL_DIR := "user://routines" const STATE_PATH := "user://sync_state.cfg" const TEMP_SUFFIX := ".part" -const UPLOAD_SUFFIX := ".uploading" ## New routines are JSON; legacy `.tres` files stay in the sync so existing -## installations do not lose their server copies. Audio attachments (the music +## installations do not lose their cloud copies. Audio attachments (the music ## of a routine) live in the same folder and are synced like the routine files. const SYNC_EXTENSIONS := [ ".json", @@ -19,10 +22,12 @@ const SYNC_EXTENSIONS := [ ".ogg", ".wav", ] +const PROVIDERS := ["dropbox", "google_drive"] var progress: String = "" var error: String = "" var result: Dictionary = {} +var provider: String = "" func run(settings: Dictionary) -> void: @@ -37,60 +42,48 @@ func run(settings: Dictionary) -> void: "errors": [], } error = "" + provider = str(settings.get("provider", "")).strip_edges() + + if not PROVIDERS.has(provider): + error = "Kein Cloud-Anbieter ausgewählt. Bitte die Sync-Einstellungen öffnen." + return - var host := str(settings.get("host", "")).strip_edges() - var user := str(settings.get("user", "")).strip_edges() - var password := str(settings.get("password", "")) - var port := int(settings.get("port", 21)) var directory := str(settings.get("directory", "")).strip_edges().trim_prefix("/").trim_suffix("/") - var encryption := ( - FtpClient.Encryption.EXPLICIT_TLS - if bool(settings.get("ftps", true)) - else FtpClient.Encryption.NONE - ) - var verify := bool(settings.get("verify_certificate", true)) + if directory.contains("/") or directory.contains("\\"): + error = "Der Cloud-Ordner darf keine Unterordner enthalten." + return - if host.is_empty() or user.is_empty(): - error = "Host und Benutzer müssen in den Sync-Einstellungen gesetzt sein." + var tokens := provider_tokens(settings, provider) + if str(tokens.get("refresh_token", "")).is_empty(): + error = ( + "Nicht mit %s verbunden. Bitte in den Sync-Einstellungen das Konto verbinden." + % RemoteStore.provider_label(provider) + ) + return + + var app := SyncAppConfig.load_config() + if not SyncAppConfig.is_configured(provider, app): + error = SyncAppConfig.missing_hint(provider) return _ensure_local_dir() - var client := FtpClient.new() - - progress = "Verbinde mit %s:%d …" % [host, port] - var err := client.connect_to(host, port, encryption, verify) - if not err.is_empty(): - error = err - client.close() + var store := RemoteStore.create(provider, settings, app) + if store == null: + error = "Der Cloud-Anbieter wird von dieser Version nicht unterstützt." return - progress = "Anmeldung …" - err = client.login(user, password) + progress = "Verbinde mit %s …" % RemoteStore.provider_label(provider) + var err := store.open() if not err.is_empty(): error = err - client.close() + store.close() return - if not directory.is_empty(): - err = client.change_dir(directory) - if not err.is_empty(): - progress = "Lege Zielordner an …" - var mkdir_error := client.make_dir(directory) - if not mkdir_error.is_empty(): - error = "%s (%s)" % [mkdir_error, err] - client.close() - return - err = client.change_dir(directory) - if not err.is_empty(): - error = err - client.close() - return - - progress = "Lese Serververzeichnis …" - var remote := _remote_files(client) - if not client.last_error.is_empty(): - error = client.last_error - client.close() + progress = "Lese Cloud-Ordner …" + var remote := _remote_files(store) + if not store.last_error.is_empty(): + error = store.last_error + store.close() return var local := local_files() @@ -108,27 +101,27 @@ func run(settings: Dictionary) -> void: progress = "%s: %s" % [name, SyncPlan.action_name(action)] match action: SyncPlan.Action.UPLOAD: - var upload_error := _upload(client, name) + var upload_error := _upload(store, name) if upload_error.is_empty(): result["uploaded"].append(name) transferred = true else: result["errors"].append(upload_error) SyncPlan.Action.DOWNLOAD: - var download_error := _download(client, name) + var download_error := _download(store, name) if download_error.is_empty(): result["downloaded"].append(name) transferred = true else: result["errors"].append(download_error) SyncPlan.Action.CONFLICT: - var conflict_error := _keep_both(client, name, used_names) + var conflict_error := _keep_both(store, name, used_names) if conflict_error.is_empty(): transferred = true else: result["errors"].append(conflict_error) SyncPlan.Action.TAKE_SERVER: - var adopt_error := _take_server(client, name, used_names) + var adopt_error := _take_server(store, name, used_names) if adopt_error.is_empty(): transferred = true else: @@ -138,46 +131,34 @@ func run(settings: Dictionary) -> void: if transferred: progress = "Aktualisiere Sync-Stand …" - _save_state(client, state) + _save_state(store, state) - client.close() + store.close() progress = "Fertig." -func _upload(client: FtpClient, name: String) -> String: - var local_path := _local_path(name) - var temporary := name + UPLOAD_SUFFIX - var err := client.upload(local_path, temporary) - if not err.is_empty(): - return "Upload %s: %s" % [name, err] - - var rename_error := client.rename(temporary, name) - if rename_error.is_empty(): - return "" - # Some servers refuse to overwrite on rename: remove the temp file and - # upload directly (non-atomic, but the only portable fallback). - client.delete_file(temporary) - err = client.upload(local_path, name) +func _upload(store: RemoteStore, name: String) -> String: + var err := store.upload(_local_path(name), name) if not err.is_empty(): return "Upload %s: %s" % [name, err] return "" -func _download(client: FtpClient, name: String) -> String: +func _download(store: RemoteStore, name: String) -> String: var target := _local_path(name) var temporary := target + TEMP_SUFFIX - var err := client.download(name, temporary) + var err := store.download(name, temporary) if not err.is_empty(): return "Download %s: %s" % [name, err] return _replace_file(temporary, target) ## First sync of a file that exists on both sides (no common state): the -## server copy keeps the normal name, the local copy is preserved next to it. -func _take_server(client: FtpClient, name: String, used_names: Dictionary) -> String: +## cloud copy keeps the normal name, the local copy is preserved next to it. +func _take_server(store: RemoteStore, name: String, used_names: Dictionary) -> String: var target := _local_path(name) var temporary := target + TEMP_SUFFIX - var err := client.download(name, temporary) + var err := store.download(name, temporary) if not err.is_empty(): return "Übernahme %s: %s" % [name, err] @@ -212,7 +193,7 @@ func _take_server(client: FtpClient, name: String, used_names: Dictionary) -> St return "" -func _keep_both(client: FtpClient, name: String, used_names: Dictionary) -> String: +func _keep_both(store: RemoteStore, name: String, used_names: Dictionary) -> String: var stamp := SyncPlan.timestamp_label() var conflict_name := SyncPlan.unique_name( SyncPlan.conflict_file_name(name, stamp), @@ -220,7 +201,7 @@ func _keep_both(client: FtpClient, name: String, used_names: Dictionary) -> Stri ) var target := _local_path(conflict_name) var temporary := target + TEMP_SUFFIX - var err := client.download(name, temporary) + var err := store.download(name, temporary) if not err.is_empty(): return "Konflikt %s: %s" % [name, err] @@ -259,9 +240,9 @@ func _replace_file(temporary: String, target: String) -> String: return "" -func _save_state(client: FtpClient, state: Dictionary) -> void: - # Refresh the server listing once so uploaded files get their new MDTM. - var remote_after := _remote_files(client) +func _save_state(store: RemoteStore, state: Dictionary) -> void: + # Refresh the cloud listing once so uploaded files get their new timestamp. + var remote_after := _remote_files(store) var local_after := local_files() var touched: Array = [] touched.append_array(result["uploaded"]) @@ -280,6 +261,15 @@ func _save_state(client: FtpClient, state: Dictionary) -> void: save_state(STATE_PATH, state) +static func provider_tokens(settings: Dictionary, provider_name: String) -> Dictionary: + var all_tokens: Variant = settings.get("tokens", {}) + if all_tokens is Dictionary: + var entry: Variant = (all_tokens as Dictionary).get(provider_name, {}) + if entry is Dictionary: + return (entry as Dictionary).duplicate(true) + return {} + + static func is_synced_file(name: String) -> bool: var lower := name.to_lower() for extension: String in SYNC_EXTENSIONS: @@ -293,9 +283,9 @@ static func is_routine_file(name: String) -> bool: return is_synced_file(name) -func _remote_files(client: FtpClient) -> Dictionary: +func _remote_files(store: RemoteStore) -> Dictionary: var files: Dictionary = {} - for entry: Dictionary in client.list_files(): + for entry: Dictionary in store.list_files(): var name := str(entry.get("name", "")) if not is_synced_file(name): continue diff --git a/rinkplanner/src/core/sync/sync_app_config.gd b/rinkplanner/src/core/sync/sync_app_config.gd new file mode 100644 index 0000000..0003ba0 --- /dev/null +++ b/rinkplanner/src/core/sync/sync_app_config.gd @@ -0,0 +1,92 @@ +class_name SyncAppConfig +extends RefCounted + +## OAuth app credentials of Rinkplanner itself. These are not user secrets: +## the client ID / app key identify the installed app, while every user +## authorises their own account at runtime. The values are bundled at build +## time in `res://sync_apps.cfg` (see docs/cloud-setup.md) and can be +## overridden per installation with `user://sync_apps.cfg`. +## +## `docs/credentials.txt` stays a developer file and is never read by the app. + +const BUNDLED_PATH := "res://sync_apps.cfg" +const USER_PATH := "user://sync_apps.cfg" +const SECTION := "apps" +const KEYS := [ + "google_client_id", + "google_client_secret", + "dropbox_app_key", + "dropbox_app_secret", +] + +const ENV_KEYS := { + "google_client_id": "RINKPLANNER_GOOGLE_CLIENT_ID", + "google_client_secret": "RINKPLANNER_GOOGLE_CLIENT_SECRET", + "dropbox_app_key": "RINKPLANNER_DROPBOX_APP_KEY", + "dropbox_app_secret": "RINKPLANNER_DROPBOX_APP_SECRET", +} + + +static func load_config() -> Dictionary: + var values := _empty() + for key: String in KEYS: + var env_name := str(ENV_KEYS[key]) + var env_value := OS.get_environment(env_name).strip_edges() + if not env_value.is_empty(): + values[key] = env_value + var bundled := read_file(BUNDLED_PATH) + for key: String in KEYS: + var value := str(bundled.get(key, "")) + if not value.is_empty(): + values[key] = value + var user := read_file(USER_PATH) + for key: String in KEYS: + var value := str(user.get(key, "")) + if not value.is_empty(): + values[key] = value + return values + + +static func read_file(path: String) -> Dictionary: + var values := _empty() + if not FileAccess.file_exists(path): + return values + var config := ConfigFile.new() + if config.load(path) != OK: + return values + for key: String in KEYS: + values[key] = str(config.get_value(SECTION, key, "")).strip_edges() + return values + + +static func is_configured(provider: String, app: Dictionary) -> bool: + if provider == "google_drive": + return ( + not str(app.get("google_client_id", "")).is_empty() + and not str(app.get("google_client_secret", "")).is_empty() + ) + if provider == "dropbox": + return not str(app.get("dropbox_app_key", "")).is_empty() + return false + + +static func missing_hint(provider: String) -> String: + if provider == "google_drive": + return ( + "Google Drive ist in diesem Build nicht eingerichtet. " + + "Es fehlen GOOGLE_CLIENT_ID und GOOGLE_CLIENT_SECRET " + + "(siehe docs/cloud-setup.md)." + ) + if provider == "dropbox": + return ( + "Dropbox ist in diesem Build nicht eingerichtet. " + + "Es fehlt DROPBOX_APP_KEY (siehe docs/cloud-setup.md)." + ) + return "Unbekannter Cloud-Anbieter." + + +static func _empty() -> Dictionary: + var values := {} + for key: String in KEYS: + values[key] = "" + return values diff --git a/rinkplanner/src/core/sync/sync_app_config.gd.uid b/rinkplanner/src/core/sync/sync_app_config.gd.uid new file mode 100644 index 0000000..c479779 --- /dev/null +++ b/rinkplanner/src/core/sync/sync_app_config.gd.uid @@ -0,0 +1 @@ +uid://d0h7eoxsm5r1w diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index 9cb6b17..11711e5 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -64,6 +64,7 @@ const AUTOSAVE_PATH := RoutineFile.AUTOSAVE_JSON const LEGACY_AUTOSAVE_PATH := RoutineFile.AUTOSAVE_LEGACY const SESSION_PATH := "user://session.cfg" const SYNC_SETTINGS_PATH := "user://sync.cfg" +const SYNC_PROVIDERS := ["dropbox", "google_drive"] const AUTOSAVE_DELAY_SECONDS := 1.5 const MAX_HISTORY := 50 const COMPACT_LAYOUT_WIDTH := 1280.0 @@ -100,6 +101,7 @@ const MAX_MUSIC_FILE_BYTES := 64 * 1024 * 1024 @onready var status_label: Label = %StatusLabel @onready var delete_segment_button: Button = %DeleteSegmentButton @onready var section_list: VBoxContainer = %SectionList +@onready var section_scroll: ScrollContainer = %SectionScroll @onready var add_section_button: Button = %AddSectionButton @onready var move_up_button: Button = %MoveUpButton @onready var move_down_button: Button = %MoveDownButton @@ -178,13 +180,16 @@ const MAX_MUSIC_FILE_BYTES := 64 * 1024 * 1024 @onready var calibration_distance_edit: LineEdit = %CalibrationDistanceEdit @onready var calibration_time_edit: LineEdit = %CalibrationTimeEdit @onready var sync_settings_dialog: ConfirmationDialog = %SyncSettingsDialog -@onready var sync_host_edit: LineEdit = %SyncHostEdit -@onready var sync_port_edit: LineEdit = %SyncPortEdit -@onready var sync_user_edit: LineEdit = %SyncUserEdit -@onready var sync_password_edit: LineEdit = %SyncPasswordEdit +@onready var sync_provider_option: OptionButton = %SyncProviderOption +@onready var sync_account_value: Label = %SyncAccountValue +@onready var sync_connect_button: Button = %SyncConnectButton @onready var sync_directory_edit: LineEdit = %SyncDirectoryEdit -@onready var sync_ftps_check: CheckBox = %SyncFtpsCheck -@onready var sync_verify_check: CheckBox = %SyncVerifyCheck +@onready var cloud_auth_dialog: ConfirmationDialog = %CloudAuthDialog +@onready var cloud_auth_status: Label = %CloudAuthStatus +@onready var cloud_auth_url_edit: LineEdit = %CloudAuthUrlEdit +@onready var cloud_auth_user_code: Label = %CloudAuthUserCode +@onready var cloud_auth_code_edit: LineEdit = %CloudAuthCodeEdit +@onready var cloud_auth_code_hint: Label = %CloudAuthCodeHint @onready var export_dialog: ConfirmationDialog = %ExportDialog @onready var export_name_edit: LineEdit = %ExportNameEdit @onready var export_format_option: OptionButton = %ExportFormatOption @@ -240,6 +245,12 @@ var _pending_timeline_label_time: float = 0.0 var _sync_thread: Thread var _sync_job: RoutineSync var _sync_running: bool = false +var _oauth_thread: Thread +var _oauth_job: CloudOAuthJob +var _oauth_provider: String = "" +var _oauth_verifier: String = "" +var _oauth_cancelled: bool = false +var _oauth_browser_opened: bool = false var _presentation_3d: Presentation3D var _view_3d_active: bool = false @@ -340,6 +351,10 @@ func _ready() -> void: export_folder_button.pressed.connect(_on_export_folder_pressed) export_copy_path_button.pressed.connect(_on_export_copy_path_pressed) sync_settings_dialog.confirmed.connect(_on_sync_settings_confirmed) + sync_provider_option.item_selected.connect(_on_sync_provider_selected) + sync_connect_button.pressed.connect(_on_sync_connect_pressed) + cloud_auth_dialog.confirmed.connect(_on_cloud_auth_confirmed) + cloud_auth_dialog.canceled.connect(_on_cloud_auth_canceled) label_button.pressed.connect(_open_label_dialog) labels_toggle.toggled.connect(_on_labels_toggled) segment_label_dialog.confirmed.connect(_on_label_confirmed) @@ -2789,6 +2804,7 @@ func reset_playback() -> void: _stop_music() _update_play_button() rink_canvas.clear_playback_state() + _update_section_buttons() if _view_3d_active and _presentation_3d != null: _presentation_3d.clear_pose() _update_playback_ui() @@ -2798,7 +2814,10 @@ func reset_playback() -> void: func seek_playback(time: float) -> void: _playback_time = clampf(time, 0.0, _playback_total_duration) if _playback_total_duration <= 0.0: + _playback_section_id = "" + _playback_segment_id = "" rink_canvas.clear_playback_state() + _update_section_buttons() else: _update_playback_state(0.0, true) if _playing: @@ -2833,6 +2852,7 @@ func _process(delta: float) -> void: advance_playback(delta) _sync_music_to_playback() _poll_sync_thread() + _poll_oauth_thread() if _sync_running and _sync_job != null and not _sync_job.progress.is_empty(): status_label.text = "Sync: " + _sync_job.progress @@ -2922,6 +2942,7 @@ func _refresh_playback_timeline() -> void: _playback_section_id = "" _playback_segment_id = "" rink_canvas.clear_playback_state() + _update_section_buttons() if _view_3d_active and _presentation_3d != null: _presentation_3d.clear_pose() else: @@ -2942,7 +2963,9 @@ func _update_playback_state( force_heading: bool = false ) -> void: if _playback_entries.is_empty() or _routine == null: + _playback_section_id = "" rink_canvas.clear_playback_state() + _update_section_buttons() if _view_3d_active and _presentation_3d != null: _presentation_3d.clear_pose() return @@ -3006,9 +3029,16 @@ func _update_playback_state( ) _playback_position = position + var section_changed := _playback_section_id != section_id _playback_section_id = section_id _playback_segment_id = segment.segment_id + if section_changed: + var section := _routine.get_section_by_id(section_id) + if section != null: + rink_canvas.show_section_banner(section.title) + _update_section_buttons() + rink_canvas.set_playback_state( position, _playback_heading, @@ -4285,19 +4315,21 @@ func _apply_responsive_layout() -> void: func load_sync_settings() -> Dictionary: var settings := { - "host": "", - "port": 21, - "user": "", - "password": "", + "provider": "dropbox", "directory": "", - "ftps": true, - "verify_certificate": true, + "tokens": {}, } var config := ConfigFile.new() if config.load(SYNC_SETTINGS_PATH) != OK: return settings for key: String in settings.keys(): settings[key] = config.get_value("connection", key, settings[key]) + var tokens: Variant = settings.get("tokens", {}) + if not tokens is Dictionary: + settings["tokens"] = {} + var provider := str(settings.get("provider", "")) + if not SYNC_PROVIDERS.has(provider): + settings["provider"] = "dropbox" return settings @@ -4306,34 +4338,348 @@ func save_sync_settings(settings: Dictionary) -> void: for key: String in settings.keys(): config.set_value("connection", key, settings[key]) config.save(SYNC_SETTINGS_PATH) + _protect_sync_settings() + + +func _protect_sync_settings() -> void: + # Refresh tokens are app-private, but make the file owner-only on Unix as + # well. Android's user:// storage is already sandboxed; Windows has ACLs. + if OS.get_name() not in ["Linux", "macOS", "FreeBSD", "NetBSD", "OpenBSD"]: + return + OS.execute( + "chmod", + PackedStringArray([ + "600", + ProjectSettings.globalize_path(SYNC_SETTINGS_PATH), + ]) + ) func _open_sync_settings_dialog() -> void: var settings := load_sync_settings() - sync_host_edit.text = str(settings.get("host", "")) - sync_port_edit.text = str(settings.get("port", 21)) - sync_user_edit.text = str(settings.get("user", "")) - sync_password_edit.text = str(settings.get("password", "")) + _ensure_sync_provider_items() + _apply_sync_provider_to_ui(str(settings.get("provider", "dropbox"))) sync_directory_edit.text = str(settings.get("directory", "")) - sync_ftps_check.button_pressed = bool(settings.get("ftps", true)) - sync_verify_check.button_pressed = bool(settings.get("verify_certificate", true)) - sync_settings_dialog.popup_centered(Vector2i(620, 620)) - sync_host_edit.grab_focus() + _update_sync_account(settings) + sync_settings_dialog.popup_centered(Vector2i(620, 500)) + sync_directory_edit.grab_focus() + + +func _ensure_sync_provider_items() -> void: + if sync_provider_option.item_count > 0: + return + var app := SyncAppConfig.load_config() + var has_dropbox := SyncAppConfig.is_configured("dropbox", app) + var has_google := SyncAppConfig.is_configured("google_drive", app) + if not has_dropbox and not has_google: + # Developer build without app credentials: show both so the missing + # configuration is visible instead of an empty dropdown. + has_dropbox = true + has_google = true + if has_dropbox: + sync_provider_option.add_item("Dropbox", 0) + sync_provider_option.set_item_metadata( + sync_provider_option.item_count - 1, + "dropbox" + ) + if has_google: + sync_provider_option.add_item("Google Drive", 1) + sync_provider_option.set_item_metadata( + sync_provider_option.item_count - 1, + "google_drive" + ) + + +func _apply_sync_provider_to_ui(provider: String) -> void: + for index: int in range(sync_provider_option.item_count): + if str(sync_provider_option.get_item_metadata(index)) == provider: + sync_provider_option.select(index) + return + + +func _selected_sync_provider() -> String: + _ensure_sync_provider_items() + var index := sync_provider_option.selected + if index < 0 or index >= sync_provider_option.item_count: + return "dropbox" + return str(sync_provider_option.get_item_metadata(index)) + + +func _update_sync_account(settings: Dictionary) -> void: + var provider := _selected_sync_provider() + var tokens := RoutineSync.provider_tokens(settings, provider) + var connected := not str(tokens.get("refresh_token", "")).is_empty() + if connected: + var account := str(tokens.get("account", "")).strip_edges() + sync_account_value.text = account if not account.is_empty() else "Verbunden" + sync_connect_button.text = "Trennen" + else: + sync_account_value.text = "Nicht verbunden" + sync_connect_button.text = "Verbinden…" + + +func _on_sync_provider_selected(_index: int) -> void: + _update_sync_account(load_sync_settings()) func _on_sync_settings_confirmed() -> void: - var port := int(sync_port_edit.text.strip_edges()) - if port <= 0 or port > 65535: - port = 21 - save_sync_settings({ - "host": sync_host_edit.text.strip_edges(), - "port": port, - "user": sync_user_edit.text.strip_edges(), - "password": sync_password_edit.text, - "directory": sync_directory_edit.text.strip_edges(), - "ftps": sync_ftps_check.button_pressed, - "verify_certificate": sync_verify_check.button_pressed, - }) + var settings := load_sync_settings() + var provider := _selected_sync_provider() + var directory := ( + sync_directory_edit.text.strip_edges() + .replace("/", "-") + .replace("\\", "-") + ) + if directory.is_empty() and provider == "google_drive": + directory = "Rinkplanner" + var changed := ( + str(settings.get("provider", "")) != provider + or str(settings.get("directory", "")) != directory + ) + settings["provider"] = provider + settings["directory"] = directory + save_sync_settings(settings) + if changed: + _reset_sync_state() + + +func _reset_sync_state() -> void: + if FileAccess.file_exists(RoutineSync.STATE_PATH): + DirAccess.remove_absolute( + ProjectSettings.globalize_path(RoutineSync.STATE_PATH) + ) + + +func _on_sync_connect_pressed() -> void: + var provider := _selected_sync_provider() + var settings := load_sync_settings() + var tokens := RoutineSync.provider_tokens(settings, provider) + if not str(tokens.get("refresh_token", "")).is_empty(): + _disconnect_sync_provider(provider) + return + + var app := SyncAppConfig.load_config() + if not SyncAppConfig.is_configured(provider, app): + _show_message(SyncAppConfig.missing_hint(provider)) + return + + if provider == "google_drive": + _start_google_login(app) + else: + _start_dropbox_login(app) + + +func _disconnect_sync_provider(provider: String) -> void: + var settings := load_sync_settings() + var tokens: Dictionary = settings.get("tokens", {}) + tokens.erase(provider) + settings["tokens"] = tokens + save_sync_settings(settings) + _reset_sync_state() + _update_sync_account(settings) + _show_message( + ( + "%s wurde von diesem Gerät getrennt. " + + "Die Dateien im Cloud-Konto bleiben erhalten." + ) % RemoteStore.provider_label(provider) + ) + + +func _start_google_login(app: Dictionary) -> void: + _abort_oauth_job() + _oauth_provider = "google_drive" + _oauth_cancelled = false + _oauth_browser_opened = false + _oauth_verifier = "" + _oauth_job = CloudOAuthJob.new() + _configure_cloud_auth_dialog("google_drive") + cloud_auth_dialog.popup_centered(Vector2i(620, 420)) + var started := _start_oauth_thread(_oauth_job.run_google_device.bind( + str(app.get("google_client_id", "")), + str(app.get("google_client_secret", "")) + )) + if not started: + cloud_auth_status.text = "Die Google-Anmeldung konnte nicht gestartet werden." + + +func _start_dropbox_login(app: Dictionary) -> void: + _abort_oauth_job() + _oauth_provider = "dropbox" + _oauth_cancelled = false + _oauth_browser_opened = true + _oauth_verifier = CloudOAuthJob.new_verifier() + var url := CloudOAuthJob.dropbox_authorize_url( + str(app.get("dropbox_app_key", "")), + _oauth_verifier + ) + _configure_cloud_auth_dialog("dropbox") + cloud_auth_url_edit.text = url + cloud_auth_dialog.popup_centered(Vector2i(620, 420)) + OS.shell_open(url) + + +func _configure_cloud_auth_dialog(provider: String) -> void: + cloud_auth_status.text = ( + "Fordere Anmeldecode an …" if provider == "google_drive" + else "Dropbox im Browser öffnen und den Code hier einfügen." + ) + cloud_auth_url_edit.text = "" + cloud_auth_user_code.text = "" + cloud_auth_code_edit.text = "" + cloud_auth_user_code.visible = provider == "google_drive" + cloud_auth_code_edit.visible = provider == "dropbox" + cloud_auth_code_hint.visible = provider == "dropbox" + cloud_auth_code_hint.text = "Code aus der Dropbox-Seite hier einfügen." + cloud_auth_dialog.title = ( + "Google Drive verbinden" if provider == "google_drive" + else "Dropbox verbinden" + ) + cloud_auth_dialog.dialog_hide_on_ok = false + cloud_auth_dialog.get_ok_button().text = ( + "Browser öffnen" if provider == "google_drive" else "Verbinden" + ) + + +func _on_cloud_auth_confirmed() -> void: + if _oauth_provider.is_empty(): + cloud_auth_dialog.hide() + return + if _oauth_provider == "google_drive": + var url := cloud_auth_url_edit.text.strip_edges() + if not url.is_empty(): + OS.shell_open(url) + return + + var code := cloud_auth_code_edit.text.strip_edges() + if code.is_empty(): + cloud_auth_status.text = "Bitte den Code aus der Dropbox-Seite einfügen." + return + if _oauth_thread != null and _oauth_thread.is_alive(): + return + var app := SyncAppConfig.load_config() + if not SyncAppConfig.is_configured("dropbox", app): + cloud_auth_status.text = SyncAppConfig.missing_hint("dropbox") + return + _oauth_cancelled = false + _oauth_job = CloudOAuthJob.new() + cloud_auth_status.text = "Tausche Anmeldecode …" + var started := _start_oauth_thread(_oauth_job.run_dropbox_exchange.bind( + str(app.get("dropbox_app_key", "")), + str(app.get("dropbox_app_secret", "")), + _oauth_verifier, + code + )) + if not started: + cloud_auth_status.text = "Die Dropbox-Anmeldung konnte nicht gestartet werden." + + +func _start_oauth_thread(callable: Callable) -> bool: + _oauth_thread = Thread.new() + var thread_error := _oauth_thread.start(callable) + if thread_error != OK: + _oauth_thread = null + _oauth_job = null + return false + return true + + +func _poll_oauth_thread() -> void: + if _oauth_thread == null: + return + + if _oauth_job != null: + if ( + not _oauth_job.verification_url.is_empty() + and cloud_auth_url_edit.text != _oauth_job.verification_url + ): + cloud_auth_url_edit.text = _oauth_job.verification_url + if ( + not _oauth_job.user_code.is_empty() + and cloud_auth_user_code.text != _oauth_job.user_code + ): + cloud_auth_user_code.text = _oauth_job.user_code + if ( + _oauth_provider == "google_drive" + and not _oauth_browser_opened + and not _oauth_job.verification_url.is_empty() + ): + _oauth_browser_opened = true + OS.shell_open(_oauth_job.verification_url) + if ( + not _oauth_job.status.is_empty() + and cloud_auth_status.text != _oauth_job.status + ): + cloud_auth_status.text = _oauth_job.status + + if _oauth_thread.is_alive(): + return + + _oauth_thread.wait_to_finish() + _oauth_thread = null + var job := _oauth_job + _oauth_job = null + if job == null: + return + if _oauth_cancelled: + _reset_oauth_state() + return + + if not job.error.is_empty(): + cloud_auth_status.text = job.error + if _oauth_provider == "dropbox": + # The user can paste a fresh code and try again. + cloud_auth_dialog.get_ok_button().text = "Verbinden" + else: + cloud_auth_url_edit.text = "" + _oauth_provider = "" + cloud_auth_dialog.get_ok_button().text = "Schließen" + return + + _save_oauth_tokens(_oauth_provider, job.result) + var connected_provider := _oauth_provider + cloud_auth_dialog.hide() + _reset_oauth_state() + _update_sync_account(load_sync_settings()) + _show_message( + "%s ist verbunden. Der Abgleich läuft über Datei → Jetzt synchronisieren." + % RemoteStore.provider_label(connected_provider) + ) + + +func _save_oauth_tokens(provider: String, tokens: Dictionary) -> void: + var settings := load_sync_settings() + var all_tokens: Dictionary = settings.get("tokens", {}) + all_tokens[provider] = tokens.duplicate(true) + settings["tokens"] = all_tokens + save_sync_settings(settings) + _reset_sync_state() + + +func _on_cloud_auth_canceled() -> void: + _oauth_cancelled = true + if _oauth_job != null: + _oauth_job.cancelled = true + cloud_auth_dialog.hide() + if _oauth_thread == null: + _reset_oauth_state() + + +func _reset_oauth_state() -> void: + _oauth_provider = "" + _oauth_verifier = "" + _oauth_cancelled = false + _oauth_browser_opened = false + + +func _abort_oauth_job() -> void: + if _oauth_job != null: + _oauth_job.cancelled = true + if _oauth_thread != null: + if _oauth_thread.is_alive(): + _oauth_thread.wait_to_finish() + _oauth_thread = null + _oauth_job = null + _reset_oauth_state() ## Manual sync: push/pull every routine file, keep both versions on conflict. @@ -4348,7 +4694,12 @@ func start_sync() -> void: save_to_path(_current_path) var settings := load_sync_settings() - if str(settings.get("host", "")).is_empty() or str(settings.get("user", "")).is_empty(): + var provider := str(settings.get("provider", "")) + var tokens := RoutineSync.provider_tokens(settings, provider) + if ( + not SYNC_PROVIDERS.has(provider) + or str(tokens.get("refresh_token", "")).is_empty() + ): _open_sync_settings_dialog() return @@ -4408,7 +4759,7 @@ func _format_sync_summary(result: Dictionary) -> String: lines.append("Heruntergeladen: %d" % downloaded.size()) if not downloaded.is_empty(): lines.append(" " + ", ".join(downloaded)) - lines.append("Vom Server übernommen: %d" % adopted.size()) + lines.append("Vom Cloud-Konto übernommen: %d" % adopted.size()) for index: int in range(adopted.size()): var backup := "" if index < backups.size(): @@ -4441,7 +4792,7 @@ func _reload_after_sync(result: Dictionary) -> void: if is_dirty(): _refresh_synced_music(result) _show_message( - "Die geöffnete Kür wurde vom Server aktualisiert, hat aber " + "Die geöffnete Kür wurde aus der Cloud aktualisiert, hat aber " + "ungespeicherte Änderungen. Bitte manuell speichern oder neu laden." ) return @@ -4465,6 +4816,11 @@ func _refresh_synced_music(result: Dictionary) -> void: func _exit_tree() -> void: + if _oauth_job != null: + _oauth_job.cancelled = true + if _oauth_thread != null: + _oauth_thread.wait_to_finish() + _oauth_thread = null if _sync_thread != null: _sync_thread.wait_to_finish() _sync_thread = null @@ -4781,7 +5137,7 @@ func _rebuild_section_list() -> void: var section: RoutineSection = _routine.sections[index] var button := Button.new() button.toggle_mode = true - button.button_pressed = section.section_id == _active_section.section_id + button.button_pressed = false button.text = "%d · %s" % [index + 1, section.title] button.tooltip_text = section.title button.custom_minimum_size = Vector2(0.0, 56.0) @@ -4794,12 +5150,54 @@ func _rebuild_section_list() -> void: _update_section_buttons() +## Section shown as "current" in the right list: while the playback has a +## position, that section; otherwise the editing selection. +func _highlight_section_id() -> String: + if ( + not _playback_section_id.is_empty() + and _routine != null + and _routine.get_section_by_id(_playback_section_id) != null + ): + return _playback_section_id + if _active_section != null: + return _active_section.section_id + return "" + + func _update_section_buttons() -> void: + var highlight_id := _highlight_section_id() + var active_id := "" + if _active_section != null: + active_id = _active_section.section_id + if _routine == null: + move_up_button.disabled = true + move_down_button.disabled = true + delete_button.disabled = true + return + for section_id: String in _section_buttons.keys(): var button: Button = _section_buttons[section_id] - button.set_pressed_no_signal(section_id == _active_section.section_id) + var section := _routine.get_section_by_id(section_id) + var index := _find_section_index(section_id) + if section != null: + var marker := "▶ " if section_id == highlight_id else "" + button.text = "%s%d · %s" % [marker, index + 1, section.title] + if section_id == highlight_id: + button.add_theme_color_override( + "font_color", + Color(0.72, 0.85, 1.0, 1.0) + ) + else: + button.remove_theme_color_override("font_color") + button.set_pressed_no_signal(section_id == active_id) - var active_index := _find_section_index(_active_section.section_id) + var highlighted_button: Button = _section_buttons.get(highlight_id) + if highlighted_button != null and section_scroll != null: + section_scroll.ensure_control_visible(highlighted_button) + + var active_index := -1 + if _active_section != null: + active_index = _find_section_index(_active_section.section_id) move_up_button.disabled = active_index <= 0 move_down_button.disabled = ( active_index < 0 or active_index >= _routine.sections.size() - 1 diff --git a/rinkplanner/src/whiteboard/view/rink_canvas.gd b/rinkplanner/src/whiteboard/view/rink_canvas.gd index 4c85df3..f0e4e74 100644 --- a/rinkplanner/src/whiteboard/view/rink_canvas.gd +++ b/rinkplanner/src/whiteboard/view/rink_canvas.gd @@ -57,6 +57,11 @@ const SEGMENT_HIT_RADIUS_PX := 14.0 const HANDLE_HIT_RADIUS_PX := 22.0 const HANDLE_RADIUS_PX := 7.0 const TOUCH_MOUSE_GUARD_MSEC := 300 +const SECTION_BANNER_DURATION := 2.0 +const SECTION_BANNER_FADE_IN := 0.15 +const SECTION_BANNER_FADE_OUT := 0.6 +const SECTION_BANNER_TOP := 18.0 +const SECTION_BANNER_FONT_SIZE := 22 @export var fit_padding_px: float = 32.0 @export var drawing_enabled: bool = true @@ -96,6 +101,11 @@ var _playback_section_id: String = "" var _playback_edge: PathSegment.Edge = PathSegment.Edge.OUTSIDE var _playback_direction: PathSegment.Direction = PathSegment.Direction.FORWARD +var _section_banner_text: String = "" +var _section_banner_elapsed: float = 0.0 +var _section_banner_remaining: float = 0.0 +var _section_banner_duration: float = 0.0 + # Screen-space polyline cache. During playback only the marker moves, so the # sampled paths can be reused instead of re-baking every curve each frame. var _curve_cache: Dictionary[int, Dictionary] = {} @@ -106,6 +116,7 @@ var _curve_cache_origin: Vector2 = Vector2.INF func _ready() -> void: focus_mode = Control.FOCUS_ALL mouse_filter = Control.MOUSE_FILTER_STOP + set_process(false) fit_rink() @@ -214,6 +225,7 @@ func set_playback_state( func clear_playback_state() -> void: _playback_visible = false _playback_section_id = "" + hide_section_banner() queue_redraw() @@ -221,6 +233,69 @@ func get_playback_section_id() -> String: return _playback_section_id +## Shows the current section name at the top of the rink. It fades in briefly, +## stays readable and fades out before [param duration] seconds are over. +func show_section_banner(text: String, duration: float = SECTION_BANNER_DURATION) -> void: + var cleaned := text.strip_edges() + if cleaned.is_empty(): + hide_section_banner() + return + _section_banner_text = cleaned + _section_banner_duration = maxf(duration, SECTION_BANNER_FADE_IN + SECTION_BANNER_FADE_OUT) + _section_banner_elapsed = 0.0 + _section_banner_remaining = _section_banner_duration + set_process(true) + queue_redraw() + + +func hide_section_banner() -> void: + _section_banner_text = "" + _section_banner_elapsed = 0.0 + _section_banner_remaining = 0.0 + _section_banner_duration = 0.0 + set_process(false) + queue_redraw() + + +func get_section_banner_text() -> String: + return _section_banner_text + + +func get_section_banner_alpha() -> float: + return _banner_alpha() + + +func _process(delta: float) -> void: + if _section_banner_text.is_empty() or _section_banner_duration <= 0.0: + set_process(false) + return + _section_banner_elapsed += delta + _section_banner_remaining = maxf( + _section_banner_duration - _section_banner_elapsed, + 0.0 + ) + if _section_banner_remaining <= 0.0: + hide_section_banner() + return + queue_redraw() + + +func _banner_alpha() -> float: + if _section_banner_text.is_empty() or _section_banner_duration <= 0.0: + return 0.0 + var fade_in := clampf( + _section_banner_elapsed / SECTION_BANNER_FADE_IN, + 0.0, + 1.0 + ) + var fade_out := clampf( + _section_banner_remaining / SECTION_BANNER_FADE_OUT, + 0.0, + 1.0 + ) + return minf(fade_in, fade_out) + + ## Aborts any in-progress draw/handle gesture and clears the selection. func cancel_interaction() -> void: _abort_handle_drag() @@ -285,6 +360,8 @@ func _draw() -> void: if _playback_visible: _draw_playback_marker() + _draw_section_banner() + func _draw_center_line() -> void: var half_width := _rink.get_half_width() @@ -431,6 +508,59 @@ func _draw_playback_marker() -> void: ) +func _draw_section_banner() -> void: + var alpha := _banner_alpha() + if alpha <= 0.0: + return + var font := ThemeDB.fallback_font + var text_size := font.get_string_size( + _section_banner_text, + HORIZONTAL_ALIGNMENT_LEFT, + -1, + SECTION_BANNER_FONT_SIZE + ) + var padding := Vector2(20.0, 9.0) + var box := Vector2( + text_size.x + padding.x * 2.0, + SECTION_BANNER_FONT_SIZE + padding.y * 2.0 + ) + var rise := (1.0 - smoothstep(0.0, SECTION_BANNER_FADE_IN, _section_banner_elapsed)) * 8.0 + var top_left := Vector2( + (size.x - box.x) * 0.5, + SECTION_BANNER_TOP + rise + ) + var rect := Rect2(top_left, box) + var background := Color(0.035, 0.065, 0.12, 0.82 * alpha) + var border := Color(0.55, 0.72, 0.94, 0.85 * alpha) + var accent := Color(0.38, 0.65, 0.98, alpha) + var text_color := Color(0.96, 0.98, 1.0, alpha) + var shadow := Color(0.0, 0.0, 0.0, 0.35 * alpha) + + draw_rect(Rect2(rect.position + Vector2(2.0, 3.0), rect.size), shadow, true) + draw_rect(rect, background, true) + draw_rect(rect, border, false, 1.5) + draw_rect( + Rect2( + Vector2(rect.position.x, rect.end.y - 3.0), + Vector2(rect.size.x, 3.0) + ), + accent, + true + ) + draw_string( + font, + Vector2( + rect.position.x + padding.x, + rect.position.y + padding.y + font.get_ascent(SECTION_BANNER_FONT_SIZE) + ), + _section_banner_text, + HORIZONTAL_ALIGNMENT_LEFT, + -1, + SECTION_BANNER_FONT_SIZE, + text_color + ) + + func _draw_section(section: RoutineSection, alpha: float) -> void: var step_px := GHOST_SAMPLE_STEP_PX if alpha < 1.0 else CURVE_SAMPLE_STEP_PX for segment: PathSegment in section.segments: diff --git a/rinkplanner/src/whiteboard/view/timeline_label_lane.gd b/rinkplanner/src/whiteboard/view/timeline_label_lane.gd index aa33834..bea5918 100644 --- a/rinkplanner/src/whiteboard/view/timeline_label_lane.gd +++ b/rinkplanner/src/whiteboard/view/timeline_label_lane.gd @@ -25,6 +25,8 @@ var _element_labels: Array[Dictionary] = [] var _custom_labels: Array[Dictionary] = [] var _items: Array[Dictionary] = [] var _hover_index: int = -1 +var _hover_item_index: int = -1 +var _default_tooltip := "" func _ready() -> void: @@ -35,6 +37,7 @@ func _ready() -> void: "Klick: Timeline-Label hinzufügen · " + "Klick auf ein goldenes Label: bearbeiten" ) + _default_tooltip = tooltip_text resized.connect(_rebuild_items) _rebuild_items() @@ -76,8 +79,39 @@ func get_display_items() -> Array[Dictionary]: return result +## Track time of the label under [param position], or -1 outside a label. +func get_label_time_at(position: Vector2) -> float: + var index := _item_index_at(position) + if index < 0: + return -1.0 + return float(_items[index].get("time_seconds", -1.0)) + + +## Tooltip for the label under [param position]; falls back to the lane hint. +func get_tooltip_at(position: Vector2) -> String: + var index := _item_index_at(position) + if index < 0: + return _default_tooltip + var item: Dictionary = _items[index] + var time_text := format_time(float(item.get("time_seconds", 0.0))) + if bool(item.get("custom", false)): + return "Label: %s\nZeit: %s" % [str(item.get("display", "")), time_text] + return "%s · %s" % [ + str(item.get("display", "")), + time_text, + ] + + +static func format_time(time_seconds: float) -> String: + return ("%.1f s" % time_seconds).replace(".", ",") + + func _rebuild_items() -> void: _items.clear() + _hover_index = -1 + _hover_item_index = -1 + mouse_default_cursor_shape = Control.CURSOR_ARROW + tooltip_text = _default_tooltip if _duration <= 0.0: queue_redraw() return @@ -211,14 +245,19 @@ func _draw() -> void: func _gui_input(event: InputEvent) -> void: if event is InputEventMouseMotion: - var hovered := _custom_index_at(event.position.x) - if hovered != _hover_index: - _hover_index = hovered + var item_index := _item_index_at(event.position) + if item_index != _hover_item_index: + _hover_item_index = item_index + var custom_index := -1 + if item_index >= 0 and bool(_items[item_index]["custom"]): + custom_index = int(_items[item_index]["index"]) + _hover_index = custom_index mouse_default_cursor_shape = ( Control.CURSOR_POINTING_HAND - if hovered >= 0 + if custom_index >= 0 else Control.CURSOR_ARROW ) + tooltip_text = get_tooltip_at(event.position) queue_redraw() return @@ -238,12 +277,36 @@ func _gui_input(event: InputEvent) -> void: func _notification(what: int) -> void: - if what == NOTIFICATION_MOUSE_EXIT and _hover_index >= 0: + if what == NOTIFICATION_MOUSE_EXIT: _hover_index = -1 + _hover_item_index = -1 mouse_default_cursor_shape = Control.CURSOR_ARROW + tooltip_text = _default_tooltip queue_redraw() +func _item_index_at(position: Vector2) -> int: + var best_index := -1 + var best_distance := 100000.0 + for index: int in range(_items.size()): + var item: Dictionary = _items[index] + var x := float(item["x"]) + var baseline := size.y - 5.0 - float(int(item["row"])) * ROW_HEIGHT + var origin := Vector2(x + 2.0, baseline) + var local := (position - origin).rotated(-ROTATION) + var width := float(item["width"]) + if local.x < -4.0 or local.x > width + 8.0: + continue + if local.y < -FONT_SIZE - 6.0 or local.y > 6.0: + continue + var center := Vector2(width * 0.5, -FONT_SIZE * 0.5) + var distance := (local - center).length_squared() + if distance < best_distance: + best_distance = distance + best_index = index + return best_index + + func _custom_index_at(x: float) -> int: var best_index := -1 var best_distance := 100000.0 diff --git a/rinkplanner/sync_apps.example.cfg b/rinkplanner/sync_apps.example.cfg new file mode 100644 index 0000000..e249421 --- /dev/null +++ b/rinkplanner/sync_apps.example.cfg @@ -0,0 +1,21 @@ +; Vorlage für die OAuth-App-Zugänge von Rinkplanner. +; +; Diese Werte gehören zur App, nicht zu einem Nutzerkonto. Jeder Nutzer +; autorisiert später sein eigenes Google-/Dropbox-Konto; die App speichert nur +; dessen Refresh-Token lokal unter user://sync.cfg. +; +; Die Datei wird beim Build als res://sync_apps.cfg eingebettet. Für die +; Entwicklung kann sie auch unter user://sync_apps.cfg liegen oder über +; Umgebungsvariablen gesetzt werden (siehe docs/cloud-setup.md). +; +; Wichtig: ConfigFile-Kommentare beginnen mit ';'. Werte sind Strings und +; müssen in Anführungszeichen stehen. +; +; Nicht mit echten Werten einchecken: rinkplanner/sync_apps.cfg ist in +; .gitignore eingetragen. docs/credentials.txt bleibt die Entwicklerdatei. + +[apps] +google_client_id="" +google_client_secret="" +dropbox_app_key="" +dropbox_app_secret="" diff --git a/rinkplanner/tests/README.md b/rinkplanner/tests/README.md index c5999b8..39549f9 100644 --- a/rinkplanner/tests/README.md +++ b/rinkplanner/tests/README.md @@ -64,7 +64,7 @@ $GODOT --headless --path rinkplanner --script res://tests/run_touch_tests.gd # Run canvas performance stress test $GODOT --headless --path rinkplanner --script res://tests/run_perf_tests.gd -# Run FTP sync planning/parser/settings tests +# Run cloud sync planning/helper/settings tests $GODOT --headless --path rinkplanner --script res://tests/run_sync_tests.gd ``` diff --git a/rinkplanner/tests/run_playback_tests.gd b/rinkplanner/tests/run_playback_tests.gd index 9553bae..60d0823 100644 --- a/rinkplanner/tests/run_playback_tests.gd +++ b/rinkplanner/tests/run_playback_tests.gd @@ -133,6 +133,18 @@ func _run() -> void: controller.rink_canvas.get_playback_section_id() == section_one.section_id, "canvas highlights the playing section" ) + _check( + controller.rink_canvas.get_section_banner_text() == section_one.title, + "section banner names the section at playback" + ) + _check( + controller._section_buttons[section_one.section_id].text.begins_with("▶ "), + "section list marks the playing section" + ) + _check( + controller._section_buttons[section_two.section_id].button_pressed, + "section list keeps the editing selection" + ) controller.seek_playback(3.0) _check_vec( @@ -167,6 +179,23 @@ func _run() -> void: controller.rink_canvas.get_playback_section_id() == section_two.section_id, "canvas highlights the second section" ) + _check( + controller.rink_canvas.get_section_banner_text() == section_two.title, + "section banner follows the new section" + ) + _check( + controller._section_buttons[section_two.section_id].text.begins_with("▶ "), + "section list marks the second section" + ) + controller.rink_canvas._process(2.1) + _check( + controller.rink_canvas.get_section_banner_text().is_empty(), + "section banner fades out within two seconds" + ) + _check( + controller.rink_canvas.get_section_banner_alpha() == 0.0, + "faded section banner has no alpha" + ) controller.play_button.pressed.emit() _check(controller.is_playing(), "play button starts playback") @@ -318,6 +347,38 @@ func _run() -> void: _check(has_spin_caption, "spin caption appears without a free-text label") _check(has_zero_caption, "zero-duration element stays on the timeline") + # Hovering an element label exposes its track time as a tooltip. + controller.timeline_label_lane.size = Vector2(600.0, 44.0) + controller.timeline_label_lane._rebuild_items() + var hover_item: Dictionary = {} + for item: Dictionary in controller.timeline_label_lane.get_display_items(): + if not bool(item["custom"]): + hover_item = item + break + _check(not hover_item.is_empty(), "element label can be hovered") + if not hover_item.is_empty(): + var hover_x := float(hover_item["x"]) + 4.0 + var hover_y := ( + controller.timeline_label_lane.size.y + - 5.0 + - float(int(hover_item["row"])) * 16.0 + - 5.0 + ) + var hover_position := Vector2(hover_x, hover_y) + _check_approx( + controller.timeline_label_lane.get_label_time_at(hover_position), + float(hover_item["time_seconds"]), + "hovering an element label yields its track time" + ) + var tooltip := controller.timeline_label_lane.get_tooltip_at(hover_position) + _check( + not tooltip.contains("Zeit im Track") + and tooltip.contains( + TimelineLabelLane.format_time(float(hover_item["time_seconds"])) + ), + "element label tooltip contains only label and track time" + ) + _check( controller.add_timeline_label(5.0, "Musikstart"), "custom timeline label is added" diff --git a/rinkplanner/tests/run_sync_tests.gd b/rinkplanner/tests/run_sync_tests.gd index a51291f..5403f88 100644 --- a/rinkplanner/tests/run_sync_tests.gd +++ b/rinkplanner/tests/run_sync_tests.gd @@ -1,7 +1,8 @@ extends SceneTree -## Headless tests for the manual FTP sync: planning rules, conflict naming, -## state persistence, protocol parsing and the settings UI wiring. +## Headless tests for the cloud sync: planning rules, conflict naming, state +## persistence, OAuth/PKCE helpers, provider path conventions and the settings +## UI wiring. ## ## Run with: ## godot --headless --path rinkplanner --script res://tests/run_sync_tests.gd @@ -19,7 +20,8 @@ func _init() -> void: func _run() -> void: _test_plan() _test_naming() - _test_parsers() + _test_cloud_helpers() + _test_app_config() _test_state_roundtrip() await _test_controller_wiring() _finish() @@ -55,17 +57,17 @@ func _test_plan() -> void: actions[entry["name"]] = entry["action"] _check(actions.get("neu.json") == SyncPlan.Action.UPLOAD, "nur lokal wird hochgeladen") - _check(actions.get("server-neu.json") == SyncPlan.Action.DOWNLOAD, "nur Server wird geladen") + _check(actions.get("server-neu.json") == SyncPlan.Action.DOWNLOAD, "nur Cloud wird geladen") _check( actions.get("beide.json") == SyncPlan.Action.CONFLICT, "beidseitige Änderung ist ein Konflikt" ) _check(actions.get("lokal.json") == SyncPlan.Action.UPLOAD, "lokale Änderung wird hochgeladen") - _check(actions.get("server.json") == SyncPlan.Action.DOWNLOAD, "Server-Änderung wird geladen") + _check(actions.get("server.json") == SyncPlan.Action.DOWNLOAD, "Cloud-Änderung wird geladen") _check(actions.get("gleich.json") == SyncPlan.Action.SKIP, "unverändert wird übersprungen") _check( actions.get("entfernt.json") == SyncPlan.Action.SKIP, - "Server-Datei verschwunden: nicht wiederherstellen" + "Cloud-Datei verschwunden: nicht wiederherstellen" ) var first_sync := SyncPlan.build( @@ -75,7 +77,7 @@ func _test_plan() -> void: ) _check( first_sync.size() == 1 and first_sync[0]["action"] == SyncPlan.Action.TAKE_SERVER, - "erster Abgleich ohne Stand übernimmt die Serverfassung" + "erster Abgleich ohne Stand übernimmt die Cloud-Fassung" ) var local_deleted := SyncPlan.build( @@ -140,26 +142,129 @@ func _test_naming() -> void: ) -func _test_parsers() -> void: - var pasv := FtpClient.parse_pasv("227 Entering Passive Mode (10,1,2,3,200,10)") - _check( - pasv.get("host") == "10.1.2.3" and pasv.get("port") == 200 * 256 + 10, - "PASV-Antwort wird geparst" +func _test_cloud_helpers() -> void: + var url := CloudHttp.parse_url( + "https://api.dropboxapi.com/2/files/list_folder?limit=10" ) _check( - FtpClient.parse_epsv("229 Entering Extended Passive Mode (|||6446|)") == 6446, - "EPSV-Antwort wird geparst" + url.get("scheme") == "https" + and url.get("host") == "api.dropboxapi.com" + and int(url.get("port", 0)) == 443 + and url.get("path") == "/2/files/list_folder?limit=10", + "HTTPS-URL wird zerlegt" + ) + var loopback := CloudHttp.parse_url("http://127.0.0.1:53682/callback") + _check( + loopback.get("host") == "127.0.0.1" + and int(loopback.get("port", 0)) == 53682, + "Loopback-URL mit Port wird zerlegt" + ) + _check(CloudHttp.parse_url("ftp://example.org").is_empty(), "FTP-URL wird abgelehnt") + _check( + CloudHttp.resolve_url("https://api.example.org/a/b", "/c/d") + == "https://api.example.org:443/c/d", + "absolute Weiterleitung wird aufgelöst" ) _check( - FtpClient.parse_epsv("229 Entering Extended Passive Mode (|||)") == -1, - "ungültige EPSV-Antwort liefert -1" + CloudHttp.resolve_url("https://api.example.org/a/b", "c") + == "https://api.example.org:443/a/c", + "relative Weiterleitung wird aufgelöst" ) - var expected := int(Time.get_unix_time_from_datetime_string("2026-10-30T09:48:28")) _check( - FtpClient.parse_mdtm("20261030094828") == expected, - "MDTM wird als Unix-Zeit gelesen" + CloudHttp.json_stringify_ascii({"name": "Kür"}).contains("\\u00fc"), + "Header-JSON escaped Umlaute" ) - _check(FtpClient.parse_mdtm("kaputt") == -1, "ungültiges MDTM liefert -1") + + # RFC 7636, Appendix B. + var verifier := "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk" + _check( + CloudOAuthJob.pkce_challenge(verifier) + == "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM", + "PKCE S256 entspricht dem Referenzwert" + ) + var generated := CloudOAuthJob.new_verifier() + _check( + generated.length() >= 43 and not generated.contains("="), + "PKCE-Verifier ist lang genug und ohne Padding" + ) + var authorize := CloudOAuthJob.dropbox_authorize_url("app-key", verifier) + _check( + authorize.contains("client_id=app-key") + and authorize.contains("token_access_type=offline") + and authorize.contains("code_challenge_method=S256") + and not authorize.contains("redirect_uri"), + "Dropbox-Autorisierungs-URL nutzt Offline-Zugriff und PKCE" + ) + + _check( + DropboxStore.remote_path("", "kuer.json") == "/kuer.json", + "Dropbox-Pfad im App-Ordner" + ) + _check( + DropboxStore.remote_path("/Rinkplanner", "kuer.json") + == "/Rinkplanner/kuer.json", + "Dropbox-Pfad im Unterordner" + ) + var content_headers := DropboxStore.content_headers("token", {"path": "/kuer.json"}) + var content_type_count := 0 + for value: String in content_headers: + if value.to_lower().begins_with("content-type:"): + content_type_count += 1 + _check( + content_type_count == 1, + "Dropbox-Content-Request hat genau einen Content-Type" + ) + var dropbox_time := DropboxStore.parse_timestamp("2026-11-09T12:34:56Z") + _check(dropbox_time > 0, "Dropbox-Zeitstempel wird gelesen") + _check(DropboxStore.parse_timestamp("kaputt") == -1, "ungültiger Dropbox-Zeitstempel liefert -1") + + var google_time := GoogleDriveStore.parse_timestamp("2026-11-09T12:34:56.123Z") + _check(google_time == dropbox_time, "Google-Zeitstempel wird ohne Millisekunden gelesen") + _check( + GoogleDriveStore.escape_query("O'Brien") == "O\\'Brien", + "Google-Drive-Suchtext wird escaped" + ) + + +func _test_app_config() -> void: + var path := "user://test_sync_apps.cfg" + var config := ConfigFile.new() + config.set_value("apps", "google_client_id", "gid") + config.set_value("apps", "google_client_secret", "gsecret") + config.set_value("apps", "dropbox_app_key", "dkey") + config.save(path) + var app := SyncAppConfig.read_file(path) + _check(app["google_client_id"] == "gid", "App-Konfiguration liest Google-Client-ID") + _check(app["dropbox_app_key"] == "dkey", "App-Konfiguration liest Dropbox-App-Key") + _check(SyncAppConfig.is_configured("google_drive", app), "Google gilt als eingerichtet") + _check(SyncAppConfig.is_configured("dropbox", app), "Dropbox gilt als eingerichtet") + app["google_client_secret"] = "" + _check(not SyncAppConfig.is_configured("google_drive", app), "fehlendes Secret blockiert Google") + DirAccess.remove_absolute(ProjectSettings.globalize_path(path)) + + # ConfigFile erwartet ';' als Kommentar und Strings in Anführungszeichen. + var literal_path := "user://test_sync_apps_literal.cfg" + var literal := FileAccess.open(literal_path, FileAccess.WRITE) + literal.store_string( + "; Kommentar\n\n[apps]\n" + + "google_client_id=\"\"\n" + + "dropbox_app_key=\"key123\"\n" + ) + literal.close() + var literal_app := SyncAppConfig.read_file(literal_path) + _check( + literal_app["dropbox_app_key"] == "key123", + "App-Konfiguration liest quoted Strings" + ) + _check( + literal_app["google_client_id"] == "", + "leere quoted Strings bleiben leer" + ) + _check( + not SyncAppConfig.is_configured("google_drive", literal_app), + "leere Google-Client-ID bleibt unkonfiguriert" + ) + DirAccess.remove_absolute(ProjectSettings.globalize_path(literal_path)) func _test_state_roundtrip() -> void: @@ -173,7 +278,7 @@ func _test_state_roundtrip() -> void: _check(loaded.size() == 2, "Sync-Stand wird gespeichert und geladen") _check( int(loaded.get("kuer.json", {}).get("remote_modify", 0)) == 222, - "Sync-Stand behält die Server-Zeit" + "Sync-Stand behält die Cloud-Zeit" ) DirAccess.remove_absolute(ProjectSettings.globalize_path(path)) @@ -211,22 +316,33 @@ func _test_controller_wiring() -> void: if controller == null: return + var app_config := SyncAppConfig.load_config() + var provider := "dropbox" + if ( + not SyncAppConfig.is_configured("dropbox", app_config) + and SyncAppConfig.is_configured("google_drive", app_config) + ): + provider = "google_drive" + var tokens := { + provider: { + "refresh_token": "refresh", + "access_token": "access", + "expires_at": 9999999999, + "account": "konto@example.org", + }, + } + controller.save_sync_settings({ - "host": "ftp.example.org", - "port": 2121, - "user": "konto", - "password": "geheim", - "directory": "rinkplanner", - "ftps": false, - "verify_certificate": false, + "provider": provider, + "directory": "Kueren", + "tokens": tokens, }) var loaded := controller.load_sync_settings() - _check(loaded["host"] == "ftp.example.org", "Sync-Einstellungen speichern den Host") - _check(int(loaded["port"]) == 2121, "Sync-Einstellungen speichern den Port") - _check(loaded["ftps"] == false, "Sync-Einstellungen speichern FTPS") + _check(loaded["provider"] == provider, "Sync-Einstellungen speichern den Anbieter") + _check(loaded["directory"] == "Kueren", "Sync-Einstellungen speichern den Cloud-Ordner") _check( - loaded["verify_certificate"] == false, - "Sync-Einstellungen speichern die Zertifikatsprüfung" + RoutineSync.provider_tokens(loaded, provider).get("refresh_token") == "refresh", + "Sync-Einstellungen speichern den Refresh-Token" ) controller._open_sync_settings_dialog() @@ -235,23 +351,39 @@ func _test_controller_wiring() -> void: "Einstellungsdialog öffnet sich" ) _check( - controller.sync_host_edit.text == "ftp.example.org", - "Dialog ist mit den gespeicherten Werten gefüllt" + controller._selected_sync_provider() == provider, + "Dialog wählt den gespeicherten Anbieter" ) _check( - controller.sync_password_edit.secret, - "Passwortfeld ist verdeckt" + controller.sync_directory_edit.text == "Kueren", + "Dialog ist mit dem gespeicherten Ordner gefüllt" + ) + _check( + controller.sync_account_value.text == "konto@example.org", + "Dialog zeigt das verbundene Konto" + ) + _check( + controller.sync_connect_button.text == "Trennen", + "Verbundenes Konto bietet Trennen an" ) controller.sync_settings_dialog.hide() - # Ohne Host öffnet "Jetzt synchronisieren" die Einstellungen statt zu starten. - controller.save_sync_settings({"host": "", "port": 21, "user": "", "password": ""}) + # Ohne Refresh-Token öffnet "Jetzt synchronisieren" die Einstellungen. + controller.save_sync_settings({ + "provider": "dropbox", + "directory": "Rinkplanner", + "tokens": {}, + }) controller.start_sync() _check( controller.sync_settings_dialog.visible, - "Sync ohne Zugangsdaten öffnet die Einstellungen" + "Sync ohne Cloud-Konto öffnet die Einstellungen" + ) + _check(not controller._sync_running, "ohne Cloud-Konto startet kein Sync") + _check( + controller.sync_account_value.text == "Nicht verbunden", + "Dialog zeigt den fehlenden Account" ) - _check(not controller._sync_running, "ohne Zugangsdaten startet kein Sync") controller.sync_settings_dialog.hide() scene.queue_free() diff --git a/tools/sync_apps_config.sh b/tools/sync_apps_config.sh new file mode 100755 index 0000000..bba4c2b --- /dev/null +++ b/tools/sync_apps_config.sh @@ -0,0 +1,76 @@ +#!/usr/bin/env bash +# Erzeugt rinkplanner/sync_apps.cfg aus docs/credentials.txt. +# +# Die OAuth-App-Zugänge sind öffentliche App-Identitäten, keine Nutzergeheimnisse. +# Sie werden beim Build als res://sync_apps.cfg eingebettet. Die Datei ist +# trotzdem gitignored, damit versehentliche Änderungen nicht im Repository landen. +# +# Aufruf: +# ./tools/sync_apps_config.sh +set -euo pipefail + +REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +CREDENTIALS="$REPO_ROOT/docs/credentials.txt" +TARGET="$REPO_ROOT/rinkplanner/sync_apps.cfg" + +if [[ ! -f "$CREDENTIALS" ]]; then + echo "FEHLER: $CREDENTIALS fehlt." >&2 + exit 1 +fi + +# Liest den letzten Wert eines KEY=WERT-Eintrags. Bewusst ohne assoziative +# Arrays, damit das Skript auch mit dem bash 3.2 von macOS läuft. +read_value() { + local key="$1" + local line + line="$(grep -E "^[[:space:]]*${key}[[:space:]]*=" "$CREDENTIALS" | tail -n 1 || true)" + if [[ -z "$line" ]]; then + return 0 + fi + local value="${line#*=}" + value="${value%$'\r'}" + value="$(printf '%s' "$value" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')" + printf '%s' "$value" +} + +write_value() { + local cfg_key="$1" + local cred_key="$2" + local value + value="$(read_value "$cred_key")" + # ConfigFile-Werte sind Godot-Varianten: Strings müssen in Anführungszeichen + # stehen, sonst wird z. B. ein App-Key als Identifier geparst. + value="${value//\\/\\\\}" + value="${value//\"/\\\"}" + printf '%s="%s"\n' "$cfg_key" "$value" +} + +{ + printf '%s\n' \ + "; Automatisch erzeugt von tools/sync_apps_config.sh" \ + "; Nicht einchecken; siehe sync_apps.example.cfg." \ + "" \ + "[apps]" + write_value google_client_id GOOGLE_CLIENT_ID + write_value google_client_secret GOOGLE_CLIENT_SECRET + write_value dropbox_app_key DROPBOX_APP_KEY + write_value dropbox_app_secret DROPBOX_APP_SECRET +} >"$TARGET" + +chmod 600 "$TARGET" +echo "Geschrieben: $TARGET" + +missing=0 +for key in GOOGLE_CLIENT_ID GOOGLE_CLIENT_SECRET DROPBOX_APP_KEY; do + if [[ -z "$(read_value "$key")" ]]; then + echo "Hinweis: $key ist in docs/credentials.txt leer." >&2 + missing=1 + fi +done +if [[ "$missing" -eq 1 ]]; then + echo "Der Cloud-Sync bleibt ohne diese Werte deaktiviert." >&2 +fi +if [[ -n "$(read_value GOOGLE_USER)$(read_value DROPBOX_USER)" ]]; then + echo "Hinweis: GOOGLE_USER/PASSWORD und DROPBOX_USER/PASSWORD werden nicht" >&2 + echo "verwendet. Die Cloud-APIs brauchen OAuth-App-Zugänge, keine Nutzerpasswörter." >&2 +fi