diff --git a/AGENTS.md b/AGENTS.md index 9dad74c..b4ed507 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -12,6 +12,9 @@ Benutzer als Admin. `storage/.installed` verhindert einen zweiten Lauf. - Uploads liegen in `storage/uploads/` (gesperrt); nur `web/` ist öffentlich. - API v1 mit Bearer-Tokens für die App; Web-UI nutzt Session + CSRF. +- App-Anbindung: `src/core/hub/` (`HubSettings`, `HubClient`, `HubJob`); + Token liegt getrennt von `sync.cfg` unter `user://hub.cfg`. Der Menüpunkt + `Datei → Kür-Hub…` erscheint nur bei geprüfter Verbindung. ## Website und Downloads diff --git a/docs/hub.md b/docs/hub.md index d552637..cf84402 100644 --- a/docs/hub.md +++ b/docs/hub.md @@ -38,7 +38,7 @@ hub/ ├── app/ # PHP: Bootstrap, DB, Auth, Routinen, Seiten, API ├── views/ # Server-gerenderte Templates ├── sql/ # schema.sql -├── web/ # DocumentRoot: index.php, .htaccess, assets/hub.css +├── web/ # DocumentRoot: index.php, .htaccess, assets/ (hub.css, logo.png) ├── install.php # Einmal-Installer (löscht sich selbst) └── app/config.example.php tools/deploy_hub.sh @@ -281,11 +281,43 @@ Auf der echten Subdomain durchgespielt: - Admin-Löschung von Nutzer samt Kür; Upload-Dateien wurden entfernt. - Sperren von `app/config.local.php`, `storage/`; Installer nach der Installation nicht mehr erreichbar. +- Godot-Client: Verbindungstest, Veröffentlichen per Multipart, Liste, + Download mit SHA-256-Prüfung, Verstecken; Hub-Menü erscheint nur mit + gültiger Verbindung. +- Lokale Kollisionen: nummerierte Kopie mit umgeschriebener Musikreferenz + und Überschreiben getestet. + +## App-Anbindung + +Die Desktop-App verbindet den Hub getrennt vom Cloud-Sync: + +1. Im Hub unter **Konto → API-Tokens** ein Token erzeugen (`rhub_…`). +2. In Rinkplanner **Datei → Sync-Einstellungen…** öffnen. +3. Im Bereich **Kür-Hub (Beta)** Adresse und Token eintragen, + **Verbinden & testen** drücken. Die App ruft `GET /api/v1/me` auf und + zeigt den Kontonamen an. +4. Erst danach erscheint **Datei → Kür-Hub…** im Dateimenü. Beim Trennen + oder nach einem abgelaufenen Token verschwindet der Eintrag wieder. + +Der Token liegt getrennt von den Cloud-Zugängen unter `user://hub.cfg` +(auf Unix Modus 600) und wird nicht in Kürdateien oder `sync.cfg` geschrieben. + +Im Hub-Dialog: + +- **Alle Küren / Meine Küren** durchsuchen; die Liste enthält alle + veröffentlichten Küren aller Beta-Konten. +- **Vom Hub laden** lädt JSON und Musik in `user://routines/`. Existiert der + Dateiname bereits, bietet die App **Nummerierte Kopie** (beide Dateien + bekommen „(Hub 2)“ und die Kür wird auf die neue Musik umgeschrieben) oder + **Überschreiben** an. Eine Musikdatei, die noch von einer anderen Kür + verwendet wird, wird nie überschrieben. +- **Aktuelle Kür veröffentlichen** speichert die geöffnete Kür als JSON und + lädt sie zusammen mit ihrer Musik hoch. Die Rechte-Checkbox ist Pflicht. +- **Aus Hub nehmen** versteckt eine eigene Kür (Admins dürfen alle + verstecken). Andere Beta-Konten sehen sie danach nicht mehr. ## Offene Punkte -- Godot-Client an die API anbinden (Token im Client speichern, Upload/Download - als Paket). - Optional: E-Mail-Versand für Einladungen und Passwort-Reset. - Optional: Quota pro Nutzer, Aufräumen alter Revisionen, Suche nach Kategorien/Saison. diff --git a/docs/manual.md b/docs/manual.md index 2147248..04396b9 100644 --- a/docs/manual.md +++ b/docs/manual.md @@ -30,6 +30,30 @@ App über den Button **?** in der Statusleiste erreichbar. Konfliktarchiv verschieben. Echte Sync-Konflikte löst die App automatisch nach dem neuesten Speicherstand auf; die ältere Fassung bleibt im Archiv. +## Kür-Hub + +Der Kür-Hub ist die gemeinsame Beta-Ablage für Küren und Musik. Er ist kein +Cloud-Spiegel und wird getrennt vom Dropbox-/Google-Drive-Sync verbunden: + +1. Im Hub im Browser unter **Konto → API-Tokens** ein Token erzeugen. +2. **Datei → Sync-Einstellungen…** öffnen, im Bereich **Kür-Hub (Beta)** + Adresse und Token eintragen und **Verbinden & testen** drücken. +3. Danach erscheint **Datei → Kür-Hub…**. Ohne erfolgreiche Verbindung wird + der Menüpunkt ausgeblendet. + +Im Hub-Dialog siehst du alle veröffentlichten Küren der Beta-Konten. Über +**Alle Küren / Meine Küren** und das Suchfeld lässt sich die Liste filtern. +**Vom Hub laden** speichert JSON und Musik unter `user://routines/`. Bei +gleichen Dateinamen fragt die App nach: **Nummerierte Kopie** legt beide +Dateien mit „(Hub 2)“ an und passt die Musikreferenz an; **Überschreiben** +ersetzt die vorhandenen Dateien. Musik, die noch eine andere Kür verwendet, +wird nie überschrieben. + +**Aktuelle Kür veröffentlichen** lädt die geöffnete, gespeicherte Kür samt +Musik in den Hub; die Rechte-Checkbox ist Pflicht. **Aus Hub nehmen** +versteckt eine eigene Kür wieder (Admins dürfen alle verstecken). Der Token +liegt getrennt von den Cloud-Zugängen in `user://hub.cfg`. + ## Laufwege zeichnen - **Linie** und die beiden **Bogen**-Werkzeuge erzeugen eine gerade Strecke diff --git a/docs/sync.md b/docs/sync.md index 1247fc2..8983197 100644 --- a/docs/sync.md +++ b/docs/sync.md @@ -2,9 +2,13 @@ Der Abgleich zwischen Desktop und Tablet läuft **manuell** über den eigenen Cloud-Speicher des Nutzers: Dropbox. Google Drive ist im Code vorbereitet, -aber derzeit nicht freigeschaltet. 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. +aber derzeit nicht freigeschaltet. Jeder Nutzer verbindet sein eigenes Konto; +die App speichert nur den Refresh-Token lokal auf dem Gerät. + +Der **Kür-Hub** ist etwas anderes: eine gemeinsame Beta-Ablage, in der +ausgewählte Küren mit anderen Konten getauscht werden. Er ersetzt den +Cloud-Sync nicht und wird in den Sync-Einstellungen separat verbunden +(siehe [`docs/hub.md`](hub.md)). ## Einrichten diff --git a/rinkplanner/scenes/whiteboard/whiteboard.tscn b/rinkplanner/scenes/whiteboard/whiteboard.tscn index 2c0633f..6edce31 100644 --- a/rinkplanner/scenes/whiteboard/whiteboard.tscn +++ b/rinkplanner/scenes/whiteboard/whiteboard.tscn @@ -1082,7 +1082,8 @@ cancel_button_text = "Abbrechen" [node name="SyncSettingsDialog" type="ConfirmationDialog" parent="."] unique_name_in_owner = true title = "Sync-Einstellungen" -size = Vector2i(620, 460) +size = Vector2i(620, 680) +exclusive = false ok_button_text = "Speichern" cancel_button_text = "Abbrechen" @@ -1090,7 +1091,7 @@ cancel_button_text = "Abbrechen" offset_left = 12.0 offset_top = 12.0 offset_right = 608.0 -offset_bottom = 390.0 +offset_bottom = 610.0 theme_override_constants/separation = 4 [node name="SyncHint" type="Label" parent="SyncSettingsDialog/SyncBox"] @@ -1146,6 +1147,91 @@ theme_override_font_sizes/font_size = 13 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="HubSeparator" type="HSeparator" parent="SyncSettingsDialog/SyncBox"] +layout_mode = 2 + +[node name="HubTitle" type="Label" parent="SyncSettingsDialog/SyncBox"] +layout_mode = 2 +theme_override_colors/font_color = Color(0.92549, 0.980392, 1, 1) +theme_override_font_sizes/font_size = 17 +text = "Kür-Hub (Beta)" + +[node name="HubHint" 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 = "Gemeinsame Beta-Ablage für Küren und Musik. Der Hub ist kein Cloud-Spiegel: Du lädst einzelne Küren hoch und andere herunter." +autowrap_mode = 2 + +[node name="HubUrlRow" type="HBoxContainer" parent="SyncSettingsDialog/SyncBox"] +layout_mode = 2 +theme_override_constants/separation = 8 + +[node name="HubUrlLabel" type="Label" parent="SyncSettingsDialog/SyncBox/HubUrlRow"] +custom_minimum_size = Vector2(90, 0) +layout_mode = 2 +text = "Adresse" +vertical_alignment = 1 + +[node name="HubUrlEdit" type="LineEdit" parent="SyncSettingsDialog/SyncBox/HubUrlRow"] +unique_name_in_owner = true +custom_minimum_size = Vector2(0, 44) +layout_mode = 2 +size_flags_horizontal = 3 +placeholder_text = "https://rinkplanner-hub.programmschmiede.de" +select_all_on_focus = true + +[node name="HubTokenRow" type="HBoxContainer" parent="SyncSettingsDialog/SyncBox"] +layout_mode = 2 +theme_override_constants/separation = 8 + +[node name="HubTokenLabel" type="Label" parent="SyncSettingsDialog/SyncBox/HubTokenRow"] +custom_minimum_size = Vector2(90, 0) +layout_mode = 2 +text = "API-Token" +vertical_alignment = 1 + +[node name="HubTokenEdit" type="LineEdit" parent="SyncSettingsDialog/SyncBox/HubTokenRow"] +unique_name_in_owner = true +custom_minimum_size = Vector2(0, 44) +layout_mode = 2 +size_flags_horizontal = 3 +placeholder_text = "rhub_…" +secret = true +select_all_on_focus = true + +[node name="HubAccountRow" type="HBoxContainer" parent="SyncSettingsDialog/SyncBox"] +layout_mode = 2 +theme_override_constants/separation = 8 + +[node name="HubAccountLabel" type="Label" parent="SyncSettingsDialog/SyncBox/HubAccountRow"] +custom_minimum_size = Vector2(90, 0) +layout_mode = 2 +text = "Konto" +vertical_alignment = 1 + +[node name="HubAccountValue" type="Label" parent="SyncSettingsDialog/SyncBox/HubAccountRow"] +unique_name_in_owner = true +layout_mode = 2 +size_flags_horizontal = 3 +text = "Nicht verbunden" +autowrap_mode = 2 + +[node name="HubConnectButton" type="Button" parent="SyncSettingsDialog/SyncBox/HubAccountRow"] +unique_name_in_owner = true +custom_minimum_size = Vector2(170, 44) +layout_mode = 2 +text = "Verbinden & testen" + +[node name="HubHint2" 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 = "Den Token erzeugst du im Hub unter Konto → API-Tokens. Er wird getrennt von den Cloud-Zugängen unter user://hub.cfg gespeichert." +autowrap_mode = 2 + [node name="CleanupConflictsDialog" type="ConfirmationDialog" parent="."] unique_name_in_owner = true title = "Alte Konfliktkopien aufräumen" @@ -1754,3 +1840,131 @@ offset_bottom = 616.0 bbcode_enabled = true scroll_active = true selection_enabled = true + +[node name="HubDialog" type="AcceptDialog" parent="."] +unique_name_in_owner = true +title = "Kür-Hub" +size = Vector2i(980, 700) +exclusive = false +ok_button_text = "Schließen" + +[node name="HubBox" type="VBoxContainer" parent="HubDialog"] +offset_left = 12.0 +offset_top = 12.0 +offset_right = 968.0 +offset_bottom = 640.0 +theme_override_constants/separation = 6 + +[node name="HubDialogAccount" type="Label" parent="HubDialog/HubBox"] +unique_name_in_owner = true +layout_mode = 2 +theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) +theme_override_font_sizes/font_size = 14 +text = "Nicht verbunden" +autowrap_mode = 2 + +[node name="HubSearchRow" type="HBoxContainer" parent="HubDialog/HubBox"] +layout_mode = 2 +theme_override_constants/separation = 6 + +[node name="HubSearchEdit" type="LineEdit" parent="HubDialog/HubBox/HubSearchRow"] +unique_name_in_owner = true +custom_minimum_size = Vector2(0, 44) +layout_mode = 2 +size_flags_horizontal = 3 +placeholder_text = "Titel, Skater, Musik oder Benutzer suchen …" +select_all_on_focus = true + +[node name="HubSearchButton" type="Button" parent="HubDialog/HubBox/HubSearchRow"] +unique_name_in_owner = true +custom_minimum_size = Vector2(110, 44) +layout_mode = 2 +text = "Suchen" + +[node name="HubFilterOption" type="OptionButton" parent="HubDialog/HubBox/HubSearchRow"] +unique_name_in_owner = true +custom_minimum_size = Vector2(160, 44) +layout_mode = 2 + +[node name="HubRefreshButton" type="Button" parent="HubDialog/HubBox/HubSearchRow"] +unique_name_in_owner = true +custom_minimum_size = Vector2(120, 44) +layout_mode = 2 +text = "Aktualisieren" + +[node name="HubStatusLabel" type="Label" parent="HubDialog/HubBox"] +unique_name_in_owner = true +layout_mode = 2 +theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) +theme_override_font_sizes/font_size = 14 +text = "Bereit." +autowrap_mode = 2 + +[node name="HubTree" type="Tree" parent="HubDialog/HubBox"] +unique_name_in_owner = true +custom_minimum_size = Vector2(0, 360) +layout_mode = 2 +size_flags_vertical = 3 +columns = 5 +column_titles_visible = true +hide_root = true +select_mode = 1 + +[node name="HubDetailLabel" type="Label" parent="HubDialog/HubBox"] +unique_name_in_owner = true +custom_minimum_size = Vector2(0, 56) +layout_mode = 2 +theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) +theme_override_font_sizes/font_size = 14 +text = "Wähle eine Kür aus der Liste." +autowrap_mode = 2 + +[node name="HubActions" type="HBoxContainer" parent="HubDialog/HubBox"] +layout_mode = 2 +theme_override_constants/separation = 8 + +[node name="HubDownloadButton" type="Button" parent="HubDialog/HubBox/HubActions"] +unique_name_in_owner = true +custom_minimum_size = Vector2(180, 46) +layout_mode = 2 +text = "Vom Hub laden" +disabled = true + +[node name="HubPublishButton" type="Button" parent="HubDialog/HubBox/HubActions"] +unique_name_in_owner = true +custom_minimum_size = Vector2(230, 46) +layout_mode = 2 +text = "Aktuelle Kür veröffentlichen" + +[node name="HubHideButton" type="Button" parent="HubDialog/HubBox/HubActions"] +unique_name_in_owner = true +custom_minimum_size = Vector2(170, 46) +layout_mode = 2 +text = "Aus Hub nehmen" +disabled = true + +[node name="HubActionsSpacer" type="Control" parent="HubDialog/HubBox/HubActions"] +layout_mode = 2 +size_flags_horizontal = 3 + +[node name="HubRightsCheck" type="CheckBox" parent="HubDialog/HubBox/HubActions"] +unique_name_in_owner = true +layout_mode = 2 +text = "Rechte an Kür und Musik bestätigt" + +[node name="HubConflictDialog" type="ConfirmationDialog" parent="."] +unique_name_in_owner = true +title = "Kür bereits vorhanden" +size = Vector2i(640, 320) +exclusive = false +ok_button_text = "Nummerierte Kopie" +cancel_button_text = "Abbrechen" + +[node name="HubConflictText" type="Label" parent="HubConflictDialog"] +unique_name_in_owner = true +offset_left = 12.0 +offset_top = 12.0 +offset_right = 628.0 +offset_bottom = 250.0 +text = "" +autowrap_mode = 2 diff --git a/rinkplanner/src/core/hub/hub_client.gd b/rinkplanner/src/core/hub/hub_client.gd new file mode 100644 index 0000000..11ec453 --- /dev/null +++ b/rinkplanner/src/core/hub/hub_client.gd @@ -0,0 +1,383 @@ +class_name HubClient +extends RefCounted + +## Blocking client for the Kür-Hub API. Like [CloudHttp], it is intended to run +## on a worker thread; the controller polls the thread and updates the UI on +## the main thread. + +const API_PREFIX := "/api/v1" +const REQUEST_TIMEOUT_MSEC := 30000 +const DOWNLOAD_TIMEOUT_MSEC := 300000 +const PENDING_DIR := "user://hub_pending" + +var base_url: String = HubSettings.DEFAULT_URL +var token: String = "" +var last_error: String = "" +var last_status: int = 0 + +var _http := CloudHttp.new() + + +func configure(settings: Dictionary) -> void: + base_url = HubSettings.normalize_url(str(settings.get("base_url", ""))) + token = str(settings.get("token", "")).strip_edges() + last_error = "" + last_status = 0 + + +func test_connection() -> Dictionary: + var data := _request_json(HTTPClient.METHOD_GET, "/me") + if data.is_empty(): + return {} + return {"user": data} + + +func list_routines(query: String = "", mine: bool = false) -> Array: + var path := "/routines?per_page=50" + var trimmed := query.strip_edges() + if not trimmed.is_empty(): + path += "&q=" + trimmed.uri_encode() + if mine: + path += "&mine=1" + var data := _request_json(HTTPClient.METHOD_GET, path) + if data.is_empty(): + return [] + var items: Variant = data.get("items", []) + var result: Array = [] + if items is Array: + result = items + return result + + +## Downloads the current revision of one routine into a temporary folder and +## verifies the SHA-256 values from the API. +func download_routine(routine_id: int) -> Dictionary: + var data := _request_json(HTTPClient.METHOD_GET, "/routines/%d" % routine_id) + if data.is_empty(): + return {} + var files: Variant = data.get("files", {}) + if not files is Dictionary: + last_error = "Der Hub hat keine Dateiliste geliefert." + return {} + var routine_info: Variant = (files as Dictionary).get("routine", {}) + if not routine_info is Dictionary: + last_error = "Der Hub hat keine Kürdatei geliefert." + return {} + var audio_info: Variant = (files as Dictionary).get("audio", null) + + var routine_name := _safe_name( + str((routine_info as Dictionary).get("name", "")), + "kuer-%d.json" % routine_id + ) + var audio_name := "" + if audio_info is Dictionary: + audio_name = _safe_name(str((audio_info as Dictionary).get("name", "")), "") + + var folder := PENDING_DIR.path_join(str(routine_id)) + if not _reset_dir(folder): + last_error = "Temporärer Hub-Ordner ist nicht beschreibbar." + return {} + + var routine_path := folder.path_join(routine_name) + var error := _download_file( + str((routine_info as Dictionary).get("url", "")), + routine_path, + str((routine_info as Dictionary).get("sha256", "")) + ) + if not error.is_empty(): + last_error = error + _remove_dir(folder) + return {} + + var audio_path := "" + if audio_info is Dictionary: + audio_path = folder.path_join(audio_name) + error = _download_file( + str((audio_info as Dictionary).get("url", "")), + audio_path, + str((audio_info as Dictionary).get("sha256", "")) + ) + if not error.is_empty(): + last_error = error + _remove_dir(folder) + return {} + + return { + "meta": data, + "folder": folder, + "routine_name": routine_name, + "routine_path": routine_path, + "audio_name": audio_name, + "audio_path": audio_path, + } + + +func publish_routine( + routine_path: String, + audio_path: String, + description: String = "", + music_title: String = "", + music_artist: String = "" +) -> Dictionary: + if not FileAccess.file_exists(routine_path): + last_error = "Die Kürdatei fehlt: %s" % routine_path + return {} + var routine_bytes := FileAccess.get_file_as_bytes(routine_path) + if routine_bytes.is_empty(): + last_error = "Die Kürdatei konnte nicht gelesen werden." + return {} + + var audio_bytes := PackedByteArray() + if not audio_path.is_empty(): + if not FileAccess.file_exists(audio_path): + last_error = "Die Audiodatei fehlt: %s" % audio_path + return {} + audio_bytes = FileAccess.get_file_as_bytes(audio_path) + if audio_bytes.is_empty(): + last_error = "Die Audiodatei konnte nicht gelesen werden." + return {} + + var boundary := "----RinkplannerHub%s%s" % [ + str(Time.get_ticks_usec()), + str(randi()), + ] + var body := PackedByteArray() + body.append_array(_field_part(boundary, "rights", "1")) + if not description.strip_edges().is_empty(): + body.append_array(_field_part(boundary, "description", description)) + if not music_title.strip_edges().is_empty(): + body.append_array(_field_part(boundary, "music_title", music_title)) + if not music_artist.strip_edges().is_empty(): + body.append_array(_field_part(boundary, "music_artist", music_artist)) + body.append_array(_file_part( + boundary, + "routine", + routine_path.get_file(), + "application/json", + routine_bytes + )) + if not audio_bytes.is_empty(): + body.append_array(_file_part( + boundary, + "audio", + audio_path.get_file(), + _audio_mime(audio_path.get_extension()), + audio_bytes + )) + body.append_array(("--%s--\r\n" % boundary).to_utf8_buffer()) + + return _request_json( + HTTPClient.METHOD_POST, + "/routines", + body, + "multipart/form-data; boundary=" + boundary + ) + + +func hide_routine(routine_id: int) -> Dictionary: + return _request_json(HTTPClient.METHOD_DELETE, "/routines/%d" % routine_id) + + +## Finds a free pair of names for a downloaded routine. Both files share the +## same number so they stay recognizable as one package. +static func numbered_names( + directory: String, + routine_name: String, + audio_name: String +) -> Dictionary: + for number: int in range(2, 1000): + var routine_candidate := _numbered_name(routine_name, number) + var audio_candidate := "" + if not audio_name.is_empty(): + audio_candidate = _numbered_name(audio_name, number) + var routine_free := not FileAccess.file_exists( + directory.path_join(routine_candidate) + ) + var audio_free := ( + audio_candidate.is_empty() + or not FileAccess.file_exists(directory.path_join(audio_candidate)) + ) + if routine_free and audio_free: + return {"routine": routine_candidate, "audio": audio_candidate} + return {} + + +static func _numbered_name(file_name: String, number: int) -> String: + var extension := file_name.get_extension() + var stem := file_name.get_basename() + return "%s (Hub %d).%s" % [stem, number, extension] + + +static func error_message(data: Variant, status: int) -> String: + if status == 401: + return ( + "Die Hub-Verbindung ist abgelaufen oder der Token wurde widerrufen. " + + "Bitte den Token in den Sync-Einstellungen erneuern." + ) + var detail := CloudHttp.error_text(data) + if detail == "HTTP-Fehler": + detail = "" + if status == 403: + return detail if not detail.is_empty() else "Keine Berechtigung für diese Aktion." + if status == 409: + return detail if not detail.is_empty() else "Die Kür ist bereits im Hub." + if status == 413: + return "Die Datei ist für den Hub zu groß." + if status == 429: + return detail if not detail.is_empty() else "Zu viele Anfragen. Bitte kurz warten." + if data is Dictionary: + var errors: Variant = (data as Dictionary).get("errors", []) + if errors is Array and not (errors as Array).is_empty(): + var parts := PackedStringArray() + for item: Variant in errors: + parts.append(str(item)) + if not parts.is_empty(): + detail = "%s\n%s" % [detail, "\n".join(parts)] + if not detail.strip_edges().is_empty(): + return detail + return "Hub-Anfrage fehlgeschlagen (HTTP %d)." % status + + +func _request_json( + method: int, + path: String, + body: PackedByteArray = PackedByteArray(), + content_type: String = "" +) -> Dictionary: + var headers := _auth_headers() + if not content_type.is_empty(): + headers.append("Content-Type: " + content_type) + var response := _http.request( + method, + base_url + API_PREFIX + path, + headers, + body, + REQUEST_TIMEOUT_MSEC + ) + if response.is_empty(): + last_error = _http.last_error + last_status = 0 + return {} + last_status = int(response.get("status", 0)) + var data: Variant = CloudHttp.json_parse(response.get("body", PackedByteArray())) + if last_status < 200 or last_status >= 300: + last_error = error_message(data, last_status) + return {} + if data is Dictionary: + return data + last_error = "Der Hub hat eine unerwartete Antwort geliefert." + return {} + + +func _download_file(url: String, target: String, expected_sha: String) -> String: + if url.is_empty(): + return "Der Hub hat keine Download-Adresse geliefert." + var response := _http.request( + HTTPClient.METHOD_GET, + url, + _auth_headers(), + PackedByteArray(), + DOWNLOAD_TIMEOUT_MSEC + ) + if response.is_empty(): + return _http.last_error + var status := int(response.get("status", 0)) + if status != 200: + return error_message( + CloudHttp.json_parse(response.get("body", PackedByteArray())), + status + ) + var payload: PackedByteArray = response.get("body", PackedByteArray()) + if payload.is_empty(): + return "Der Hub hat keine Dateidaten geliefert." + var file := FileAccess.open(target, FileAccess.WRITE) + if file == null: + return "Die heruntergeladene Datei konnte nicht gespeichert werden." + file.store_buffer(payload) + file.close() + if not expected_sha.is_empty(): + var actual := FileAccess.get_sha256(target) + if actual.to_lower() != expected_sha.to_lower(): + DirAccess.remove_absolute(ProjectSettings.globalize_path(target)) + return "Die Prüfsumme der heruntergeladenen Datei stimmt nicht." + return "" + + +func _auth_headers() -> PackedStringArray: + return PackedStringArray([ + "Accept: application/json", + "Authorization: Bearer " + token, + ]) + + +static func _field_part(boundary: String, name: String, value: String) -> PackedByteArray: + var header := ( + "--%s\r\nContent-Disposition: form-data; name=\"%s\"\r\n\r\n%s\r\n" + % [boundary, name, value] + ) + return header.to_utf8_buffer() + + +static func _file_part( + boundary: String, + name: String, + file_name: String, + mime: String, + payload: PackedByteArray +) -> PackedByteArray: + var safe_name := file_name.replace("\"", "_").replace("\r", "").replace("\n", "") + var header := ( + "--%s\r\nContent-Disposition: form-data; name=\"%s\"; filename=\"%s\"\r\n" + + "Content-Type: %s\r\n\r\n" + ) % [boundary, name, safe_name, mime] + var part := header.to_utf8_buffer() + part.append_array(payload) + part.append_array("\r\n".to_utf8_buffer()) + return part + + +static func _audio_mime(extension: String) -> String: + match extension.to_lower(): + "mp3": + return "audio/mpeg" + "ogg": + return "audio/ogg" + "wav": + return "audio/wav" + "m4a": + return "audio/mp4" + "aac": + return "audio/aac" + _: + return "application/octet-stream" + + +static func _safe_name(value: String, fallback: String) -> String: + var name := value.get_file().strip_edges() + if name.is_empty() or name == "." or name == "..": + name = fallback + if name.is_empty(): + name = "hub-datei" + return name + + +static func clear_pending(folder: String) -> void: + if not folder.is_empty(): + _remove_dir(folder) + + +static func _reset_dir(path: String) -> bool: + _remove_dir(path) + return DirAccess.make_dir_recursive_absolute(path) == OK + + +static func _remove_dir(path: String) -> void: + if not DirAccess.dir_exists_absolute(path): + return + for file: String in DirAccess.get_files_at(path): + DirAccess.remove_absolute( + ProjectSettings.globalize_path(path.path_join(file)) + ) + for subdir: String in DirAccess.get_directories_at(path): + _remove_dir(path.path_join(subdir)) + DirAccess.remove_absolute(ProjectSettings.globalize_path(path)) diff --git a/rinkplanner/src/core/hub/hub_client.gd.uid b/rinkplanner/src/core/hub/hub_client.gd.uid new file mode 100644 index 0000000..ca572d0 --- /dev/null +++ b/rinkplanner/src/core/hub/hub_client.gd.uid @@ -0,0 +1 @@ +uid://dtkjms71cmkr3 diff --git a/rinkplanner/src/core/hub/hub_job.gd b/rinkplanner/src/core/hub/hub_job.gd new file mode 100644 index 0000000..b452bad --- /dev/null +++ b/rinkplanner/src/core/hub/hub_job.gd @@ -0,0 +1,66 @@ +class_name HubJob +extends RefCounted + +## One blocking hub operation for a worker thread. The controller owns the +## thread and reads [member result]/[member error] after it has finished. + +enum Task { + TEST, + LIST, + DOWNLOAD, + PUBLISH, + HIDE, +} + +var task: Task = Task.LIST +var payload: Dictionary = {} +var result: Dictionary = {} +var error: String = "" +var progress: String = "" +var status: int = 0 + + +func run(settings: Dictionary) -> void: + error = "" + result = {} + progress = "" + status = 0 + + var client := HubClient.new() + client.configure(settings) + match task: + Task.TEST: + progress = "Verbinde mit dem Kür-Hub …" + result = client.test_connection() + Task.LIST: + progress = "Lade Küren vom Hub …" + var items: Array = client.list_routines( + str(payload.get("query", "")), + bool(payload.get("mine", false)) + ) + if client.last_error.is_empty(): + result = {"items": items} + Task.DOWNLOAD: + progress = "Lade Kür vom Hub …" + result = client.download_routine(int(payload.get("id", 0))) + Task.PUBLISH: + progress = "Veröffentliche Kür im Hub …" + result = client.publish_routine( + str(payload.get("routine_path", "")), + str(payload.get("audio_path", "")), + str(payload.get("description", "")), + str(payload.get("music_title", "")), + str(payload.get("music_artist", "")) + ) + Task.HIDE: + progress = "Nehme Kür aus dem Hub …" + result = client.hide_routine(int(payload.get("id", 0))) + _: + error = "Unbekannte Hub-Aktion." + + status = client.last_status + if result.is_empty() and error.is_empty(): + error = client.last_error + if error.is_empty(): + error = "Der Kür-Hub hat keine Daten geliefert." + progress = "" diff --git a/rinkplanner/src/core/hub/hub_job.gd.uid b/rinkplanner/src/core/hub/hub_job.gd.uid new file mode 100644 index 0000000..d0fecbc --- /dev/null +++ b/rinkplanner/src/core/hub/hub_job.gd.uid @@ -0,0 +1 @@ +uid://cppsd0odm8vt1 diff --git a/rinkplanner/src/core/hub/hub_settings.gd b/rinkplanner/src/core/hub/hub_settings.gd new file mode 100644 index 0000000..e86c715 --- /dev/null +++ b/rinkplanner/src/core/hub/hub_settings.gd @@ -0,0 +1,128 @@ +class_name HubSettings +extends RefCounted + +## Stores the Kür-Hub connection separately from the cloud sync. The API token +## is a personal credential for the Godot client; it never goes into the +## routine files or the cloud-sync configuration. + +const PATH := "user://hub.cfg" +const SECTION := "hub" +const DEFAULT_URL := "https://rinkplanner-hub.programmschmiede.de" +const TOKEN_PREFIX := "rhub_" +const MIN_TOKEN_LENGTH := 20 + + +static func load_settings() -> Dictionary: + var settings := _defaults() + var config := ConfigFile.new() + if config.load(PATH) != OK: + return settings + for key: String in settings.keys(): + settings[key] = config.get_value(SECTION, key, settings[key]) + settings["base_url"] = normalize_url(str(settings["base_url"])) + settings["token"] = str(settings["token"]).strip_edges() + settings["username"] = str(settings["username"]).strip_edges() + settings["role"] = str(settings["role"]).strip_edges() + settings["verified"] = ( + bool(settings["verified"]) + and is_token_valid(str(settings["token"])) + ) + return settings + + +static func save_settings(settings: Dictionary) -> void: + var config := ConfigFile.new() + var defaults := _defaults() + for key: String in defaults.keys(): + config.set_value(SECTION, key, settings.get(key, defaults[key])) + config.save(PATH) + _protect_file() + + +static func clear_settings() -> void: + var settings := _defaults() + save_settings(settings) + + +static func forget_token(settings: Dictionary) -> Dictionary: + var result := settings.duplicate(true) + result["token"] = "" + result["username"] = "" + result["role"] = "" + result["verified"] = false + save_settings(result) + return result + + +static func mark_unverified(settings: Dictionary) -> Dictionary: + var result := settings.duplicate(true) + result["verified"] = false + save_settings(result) + return result + + +static func mark_verified( + settings: Dictionary, + base_url: String, + token: String, + user: Dictionary +) -> Dictionary: + var result := settings.duplicate(true) + result["base_url"] = normalize_url(base_url) + result["token"] = token.strip_edges() + result["username"] = str(user.get("username", "")).strip_edges() + result["role"] = str(user.get("role", "")).strip_edges() + result["verified"] = true + save_settings(result) + return result + + +static func is_linked(settings: Dictionary) -> bool: + return ( + bool(settings.get("verified", false)) + and is_token_valid(str(settings.get("token", ""))) + and not str(settings.get("base_url", "")).strip_edges().is_empty() + ) + + +static func is_token_valid(token: String) -> bool: + var trimmed := token.strip_edges() + return ( + trimmed.begins_with(TOKEN_PREFIX) + and trimmed.length() >= MIN_TOKEN_LENGTH + ) + + +static func normalize_url(value: String) -> String: + var url := value.strip_edges() + if url.is_empty(): + return DEFAULT_URL + while url.ends_with("/"): + url = url.substr(0, url.length() - 1) + if not url.begins_with("http://") and not url.begins_with("https://"): + url = "https://" + url + for suffix: String in ["/api/v1", "/api"]: + if url.ends_with(suffix): + url = url.substr(0, url.length() - suffix.length()) + return url + + +static func _defaults() -> Dictionary: + return { + "base_url": DEFAULT_URL, + "token": "", + "username": "", + "role": "", + "verified": false, + } + + +static func _protect_file() -> void: + # The token is owner-private. Android storage is sandboxed, Windows uses + # ACLs; on Unix set the file mode explicitly. + if OS.get_name() not in ["Linux", "macOS", "FreeBSD", "NetBSD", "OpenBSD"]: + return + OS.execute( + "chmod", + PackedStringArray(["600", ProjectSettings.globalize_path(PATH)]) + ) diff --git a/rinkplanner/src/core/hub/hub_settings.gd.uid b/rinkplanner/src/core/hub/hub_settings.gd.uid new file mode 100644 index 0000000..a096e8b --- /dev/null +++ b/rinkplanner/src/core/hub/hub_settings.gd.uid @@ -0,0 +1 @@ +uid://do1aw57l7ysi7 diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index 92a896d..05abe08 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -27,6 +27,7 @@ enum FileAction { SYNC_NOW, SYNC_SETTINGS, MANAGE_ROUTINES, + HUB_OPEN, } const DEFAULT_SPEED_MPS := 4.3 @@ -248,6 +249,25 @@ const MAX_MUSIC_FILE_BYTES := 64 * 1024 * 1024 @onready var sync_provider_option: OptionButton = %SyncProviderOption @onready var sync_account_value: Label = %SyncAccountValue @onready var sync_connect_button: Button = %SyncConnectButton +@onready var hub_url_edit: LineEdit = %HubUrlEdit +@onready var hub_token_edit: LineEdit = %HubTokenEdit +@onready var hub_account_value: Label = %HubAccountValue +@onready var hub_connect_button: Button = %HubConnectButton +@onready var hub_dialog: AcceptDialog = %HubDialog +@onready var hub_dialog_account: Label = %HubDialogAccount +@onready var hub_search_edit: LineEdit = %HubSearchEdit +@onready var hub_search_button: Button = %HubSearchButton +@onready var hub_filter_option: OptionButton = %HubFilterOption +@onready var hub_refresh_button: Button = %HubRefreshButton +@onready var hub_status_label: Label = %HubStatusLabel +@onready var hub_tree: Tree = %HubTree +@onready var hub_detail_label: Label = %HubDetailLabel +@onready var hub_download_button: Button = %HubDownloadButton +@onready var hub_publish_button: Button = %HubPublishButton +@onready var hub_hide_button: Button = %HubHideButton +@onready var hub_rights_check: CheckBox = %HubRightsCheck +@onready var hub_conflict_dialog: ConfirmationDialog = %HubConflictDialog +@onready var hub_conflict_text: Label = %HubConflictText @onready var cleanup_conflicts_dialog: ConfirmationDialog = %CleanupConflictsDialog @onready var cleanup_conflicts_intro: Label = %CleanupConflictsIntro @onready var cleanup_conflicts_list: VBoxContainer = %CleanupConflictsList @@ -329,6 +349,11 @@ var _pending_timeline_label_time: float = 0.0 var _sync_thread: Thread var _sync_job: RoutineSync var _sync_running: bool = false +var _hub_thread: Thread +var _hub_job: HubJob +var _hub_running: bool = false +var _hub_items: Array[Dictionary] = [] +var _hub_pending_download: Dictionary = {} var _cleanup_candidates: Array = [] var _pending_delete_name: String = "" var _pending_rename_name: String = "" @@ -410,6 +435,7 @@ func _ready() -> void: ) _setup_tool_buttons() _setup_file_menu() + _setup_hub_controls() _setup_playback_controls() _setup_timing_controls() _setup_element_controls() @@ -3834,6 +3860,7 @@ func _process(delta: float) -> void: _sync_music_to_playback() _poll_sync_thread() _poll_oauth_thread() + _poll_hub_thread() if _sync_running and _sync_job != null and not _sync_job.progress.is_empty(): status_label.text = "Sync: " + _sync_job.progress @@ -5245,6 +5272,8 @@ func _on_file_menu_pressed(action: int) -> void: _open_sync_settings_dialog() FileAction.MANAGE_ROUTINES: _open_routine_manager() + FileAction.HUB_OPEN: + _open_hub_dialog() func _set_routine(routine: Routine, path: String) -> void: @@ -5719,7 +5748,11 @@ func _open_sync_settings_dialog() -> void: _ensure_sync_provider_items() _apply_sync_provider_to_ui(str(settings.get("provider", "dropbox"))) _update_sync_account(settings) - sync_settings_dialog.popup_centered(Vector2i(620, 460)) + var hub := HubSettings.load_settings() + hub_url_edit.text = str(hub.get("base_url", HubSettings.DEFAULT_URL)) + hub_token_edit.text = str(hub.get("token", "")) + _update_hub_account(hub) + sync_settings_dialog.popup_centered(Vector2i(620, 680)) sync_provider_option.grab_focus() @@ -5831,6 +5864,657 @@ func _disconnect_sync_provider(provider: String) -> void: ) +func _setup_hub_controls() -> void: + hub_filter_option.clear() + hub_filter_option.add_item("Alle Küren") + hub_filter_option.set_item_metadata(0, false) + hub_filter_option.add_item("Meine Küren") + hub_filter_option.set_item_metadata(1, true) + hub_filter_option.select(0) + + hub_connect_button.pressed.connect(_on_hub_connect_pressed) + hub_search_button.pressed.connect(_start_hub_list) + hub_search_edit.text_submitted.connect(_on_hub_search_submitted) + hub_filter_option.item_selected.connect(_on_hub_filter_selected) + hub_refresh_button.pressed.connect(_start_hub_list) + hub_tree.item_selected.connect(_on_hub_tree_selected) + hub_tree.item_activated.connect(_on_hub_tree_activated) + hub_download_button.pressed.connect(_on_hub_download_pressed) + hub_publish_button.pressed.connect(_on_hub_publish_pressed) + hub_hide_button.pressed.connect(_on_hub_hide_pressed) + hub_rights_check.toggled.connect(_on_hub_rights_toggled) + hub_conflict_dialog.confirmed.connect(_on_hub_conflict_copy) + hub_conflict_dialog.canceled.connect(_on_hub_conflict_cancel) + hub_conflict_dialog.custom_action.connect(_on_hub_conflict_action) + hub_conflict_dialog.add_button("Überschreiben", true, "overwrite") + + hub_tree.set_column_title(0, "Titel") + hub_tree.set_column_title(1, "Skater") + hub_tree.set_column_title(2, "Von") + hub_tree.set_column_title(3, "Rev.") + hub_tree.set_column_title(4, "Größe") + hub_tree.set_column_expand(0, true) + hub_tree.set_column_expand(1, true) + hub_tree.set_column_custom_minimum_width(2, 150) + hub_tree.set_column_custom_minimum_width(3, 60) + hub_tree.set_column_custom_minimum_width(4, 120) + + _update_hub_account(HubSettings.load_settings()) + _refresh_hub_menu() + + +func _update_hub_account(hub: Dictionary) -> void: + if HubSettings.is_linked(hub): + var username := str(hub.get("username", "")).strip_edges() + var role := str(hub.get("role", "")).strip_edges() + var suffix := " (Admin)" if role == "admin" else "" + hub_account_value.text = ( + "Verbunden als @%s%s" % [username, suffix] + if not username.is_empty() + else "Verbunden" + ) + hub_connect_button.text = "Trennen" + else: + hub_account_value.text = "Nicht verbunden" + hub_connect_button.text = "Verbinden & testen" + + +func _refresh_hub_menu() -> void: + var popup := file_menu_button.get_popup() + var found := -1 + for index: int in range(popup.item_count): + if popup.get_item_id(index) == FileAction.HUB_OPEN: + found = index + break + var connected := HubSettings.is_linked(HubSettings.load_settings()) + if connected and found < 0: + popup.add_item("Kür-Hub…", FileAction.HUB_OPEN) + elif not connected and found >= 0: + popup.remove_item(found) + if hub_dialog.visible: + hub_dialog.hide() + + +func _on_hub_connect_pressed() -> void: + if _hub_running: + return + var hub := HubSettings.load_settings() + if HubSettings.is_linked(hub): + hub = HubSettings.forget_token(hub) + hub_token_edit.text = "" + _update_hub_account(hub) + _refresh_hub_menu() + _show_message("Der Kür-Hub wurde von diesem Gerät getrennt.") + return + + var base_url := HubSettings.normalize_url(hub_url_edit.text) + var token := hub_token_edit.text.strip_edges() + var parsed_url := CloudHttp.parse_url(base_url) + if parsed_url.is_empty() or str(parsed_url.get("host", "")).is_empty(): + _show_message("Bitte eine gültige Hub-Adresse eintragen.") + return + if not HubSettings.is_token_valid(token): + _show_message( + "Bitte einen API-Token aus dem Hub eintragen " + + "(Konto → API-Tokens). Er beginnt mit „rhub_“." + ) + return + hub_url_edit.text = base_url + hub = hub.duplicate(true) + hub["base_url"] = base_url + hub["token"] = token + hub["verified"] = false + hub_account_value.text = "Verbinde …" + _start_hub_job(HubJob.Task.TEST, { + "base_url": base_url, + "token": token, + }, hub) + + +func _on_hub_search_submitted(_text: String) -> void: + _start_hub_list() + + +func _on_hub_filter_selected(_index: int) -> void: + _start_hub_list() + + +func _handle_hub_auth_error() -> void: + var hub := HubSettings.mark_unverified(HubSettings.load_settings()) + _update_hub_account(hub) + _refresh_hub_menu() + hub_status_label.text = "Verbindung abgelaufen." + _show_message( + "Die Hub-Verbindung ist abgelaufen oder der Token wurde widerrufen.\n\n" + + "Bitte den Token in den Sync-Einstellungen erneuern." + ) + + +func _start_hub_job( + task: HubJob.Task, + payload: Dictionary = {}, + settings_override: Dictionary = {} +) -> void: + if _hub_running: + return + var settings := ( + settings_override + if not settings_override.is_empty() + else HubSettings.load_settings() + ) + _hub_job = HubJob.new() + _hub_job.task = task + _hub_job.payload = payload + _hub_thread = Thread.new() + var thread_error := _hub_thread.start(_hub_job.run.bind(settings)) + if thread_error != OK: + _hub_thread = null + _hub_job = null + _show_message("Hub-Anfrage konnte nicht gestartet werden (Fehler %d)." % thread_error) + return + _hub_running = true + _set_hub_busy(true) + match task: + HubJob.Task.TEST: + hub_account_value.text = "Verbinde …" + HubJob.Task.LIST: + hub_status_label.text = "Lade Küren vom Hub …" + HubJob.Task.DOWNLOAD: + hub_status_label.text = "Lade Kür vom Hub …" + HubJob.Task.PUBLISH: + hub_status_label.text = "Veröffentliche Kür …" + HubJob.Task.HIDE: + hub_status_label.text = "Nehme Kür aus dem Hub …" + _: + hub_status_label.text = "Arbeite …" + + +func _poll_hub_thread() -> void: + if _hub_thread == null or _hub_thread.is_alive(): + return + _hub_thread.wait_to_finish() + _hub_thread = null + _hub_running = false + var job := _hub_job + _hub_job = null + _set_hub_busy(false) + if job == null: + return + _finish_hub_job(job) + + +func _set_hub_busy(busy: bool) -> void: + hub_connect_button.disabled = busy + hub_url_edit.editable = not busy + hub_token_edit.editable = not busy + hub_search_button.disabled = busy + hub_refresh_button.disabled = busy + hub_filter_option.disabled = busy + hub_rights_check.disabled = busy + if busy: + hub_download_button.disabled = true + hub_publish_button.disabled = true + hub_hide_button.disabled = true + else: + _update_hub_selection_ui() + + +func _finish_hub_job(job: HubJob) -> void: + if job.status == 401: + _handle_hub_auth_error() + return + if not job.error.is_empty(): + if job.task == HubJob.Task.TEST: + _update_hub_account(HubSettings.load_settings()) + hub_status_label.text = job.error + _show_message("Kür-Hub:\n\n" + job.error) + return + match job.task: + HubJob.Task.TEST: + _finish_hub_test(job) + HubJob.Task.LIST: + _finish_hub_list(job) + HubJob.Task.DOWNLOAD: + _finish_hub_download(job) + HubJob.Task.PUBLISH: + _finish_hub_publish(job) + HubJob.Task.HIDE: + _finish_hub_hide(job) + _: + hub_status_label.text = "Fertig." + + +func _finish_hub_test(job: HubJob) -> void: + var user: Variant = job.result.get("user", {}) + if not user is Dictionary: + _show_message("Der Hub hat kein Benutzerkonto geliefert.") + return + var tested_base := HubSettings.normalize_url( + str(job.payload.get("base_url", hub_url_edit.text)) + ) + var tested_token := str(job.payload.get("token", hub_token_edit.text)).strip_edges() + var hub := HubSettings.mark_verified( + HubSettings.load_settings(), + tested_base, + tested_token, + user + ) + _update_hub_account(hub) + _refresh_hub_menu() + hub_url_edit.text = str(hub.get("base_url", tested_base)) + hub_token_edit.text = str(hub.get("token", tested_token)) + hub_status_label.text = "Verbunden mit dem Kür-Hub." + _show_message( + "Kür-Hub verbunden als @%s." % str((user as Dictionary).get("username", "")) + ) + + +func _open_hub_dialog() -> void: + _cleanup_hub_pending() + var hub := HubSettings.load_settings() + if not HubSettings.is_linked(hub): + _show_message( + "Kein Kür-Hub verbunden. Bitte in den Sync-Einstellungen " + + "Adresse und API-Token eintragen." + ) + _open_sync_settings_dialog() + return + var username := str(hub.get("username", "")).strip_edges() + var role := str(hub.get("role", "")).strip_edges() + var suffix := " (Admin)" if role == "admin" else "" + hub_dialog_account.text = ( + "Angemeldet als @%s%s · %s" + % [username, suffix, str(hub.get("base_url", ""))] + ) + hub_search_edit.text = "" + hub_filter_option.select(0) + hub_rights_check.button_pressed = false + hub_detail_label.text = "Wähle eine Kür aus der Liste." + hub_status_label.text = "Lade Küren …" + hub_tree.clear() + hub_dialog.popup_centered(Vector2i(980, 700)) + _start_hub_list() + + +func _start_hub_list() -> void: + if _hub_running: + return + if not HubSettings.is_linked(HubSettings.load_settings()): + _handle_hub_auth_error() + return + _start_hub_job(HubJob.Task.LIST, { + "query": hub_search_edit.text.strip_edges(), + "mine": bool(hub_filter_option.get_item_metadata(hub_filter_option.selected)), + }) + + +func _finish_hub_list(job: HubJob) -> void: + var items: Variant = job.result.get("items", []) + _hub_items.clear() + if items is Array: + for entry: Variant in items: + if entry is Dictionary: + _hub_items.append(entry) + _populate_hub_tree() + var suffix := " (nur meine)" if bool( + hub_filter_option.get_item_metadata(hub_filter_option.selected) + ) else "" + hub_status_label.text = ( + "%d %s im Hub%s" + % [ + _hub_items.size(), + "Kür" if _hub_items.size() == 1 else "Küren", + suffix, + ] + ) + + +func _populate_hub_tree() -> void: + hub_tree.clear() + var root := hub_tree.create_item() + for item: Dictionary in _hub_items: + var row := hub_tree.create_item(root) + row.set_text(0, str(item.get("title", ""))) + row.set_text(1, str(item.get("skater_name", ""))) + var owner: Variant = item.get("owner", {}) + row.set_text(2, ( + str((owner as Dictionary).get("display_name", "")) + if owner is Dictionary + else "" + )) + row.set_text(3, str(item.get("revision", ""))) + row.set_text(4, _hub_size_label(item)) + row.set_metadata(0, item) + hub_detail_label.text = "Wähle eine Kür aus der Liste." + hub_download_button.disabled = true + hub_hide_button.disabled = true + hub_publish_button.disabled = not hub_rights_check.button_pressed + + +func _hub_size_label(item: Dictionary) -> String: + var routine_value: Variant = item.get("routine_bytes", 0) + var audio_value: Variant = item.get("audio_bytes", 0) + var total := ( + (int(routine_value) if routine_value != null else 0) + + (int(audio_value) if audio_value != null else 0) + ) + if total <= 0: + return "–" + if total < 1024 * 1024: + return "%d KB" % maxi(1, int(round(total / 1024.0))) + return "%.1f MB" % (total / (1024.0 * 1024.0)) + + +func _selected_hub_item() -> Dictionary: + var selected := hub_tree.get_selected() + if selected == null: + return {} + var data: Variant = selected.get_metadata(0) + return data if data is Dictionary else {} + + +func _on_hub_tree_selected() -> void: + _update_hub_selection_ui() + + +func _on_hub_tree_activated() -> void: + _on_hub_download_pressed() + + +func _update_hub_selection_ui() -> void: + var item := _selected_hub_item() + if item.is_empty(): + hub_detail_label.text = "Wähle eine Kür aus der Liste." + hub_download_button.disabled = true + hub_hide_button.disabled = true + hub_publish_button.disabled = ( + _hub_running or not hub_rights_check.button_pressed or _routine == null + ) + return + + var owner: Variant = item.get("owner", {}) + var owner_name := "" + if owner is Dictionary: + owner_name = str((owner as Dictionary).get("username", "")) + var current := HubSettings.load_settings() + var own := owner_name == str(current.get("username", "")) + var admin := str(current.get("role", "")) == "admin" + var audio: Variant = item.get("audio_bytes", null) + hub_detail_label.text = ( + "%s · Skater: %s · Von @%s · Revision %s · %s%s\n%s" + % [ + str(item.get("title", "")), + str(item.get("skater_name", "")), + owner_name, + str(item.get("revision", "–")), + _hub_size_label(item), + " · mit Musik" if audio != null else "", + ( + "Eigene Kür – kann aus dem Hub genommen werden." + if own or admin + else "Kür eines anderen Beta-Kontos." + ), + ] + ) + hub_download_button.disabled = _hub_running or item.get("revision", null) == null + hub_hide_button.disabled = _hub_running or not (own or admin) + hub_publish_button.disabled = ( + _hub_running or not hub_rights_check.button_pressed or _routine == null + ) + + +func _on_hub_rights_toggled(_pressed: bool) -> void: + _update_hub_selection_ui() + + +func _on_hub_download_pressed() -> void: + var item := _selected_hub_item() + if item.is_empty() or _hub_running: + return + var routine_id := int(item.get("id", 0)) + if routine_id <= 0: + return + _start_hub_job(HubJob.Task.DOWNLOAD, {"id": routine_id}) + + +func _on_hub_publish_pressed() -> void: + if _hub_running: + return + if not hub_rights_check.button_pressed: + _show_message("Bitte zuerst bestätigen, dass du Kür und Musik teilen darfst.") + return + if _routine == null: + _show_message("Es ist keine Kür geöffnet.") + return + if _current_path.is_empty(): + _show_message( + "Bitte die Kür zuerst speichern (Datei → Speichern unter…), " + + "bevor sie in den Hub hochgeladen wird." + ) + return + if not save_to_path(_current_path): + return + var audio_path := "" + if _routine.has_music(): + audio_path = ROUTINES_DIR.path_join(_routine.music_file) + if not FileAccess.file_exists(audio_path): + _show_message( + "Die Musikdatei „%s“ fehlt lokal. Bitte zuerst die Musik " + % _routine.music_file + + "zuordnen oder die Kür ohne Musik speichern." + ) + return + _start_hub_job(HubJob.Task.PUBLISH, { + "routine_path": _current_path, + "audio_path": audio_path, + }) + + +func _on_hub_hide_pressed() -> void: + var item := _selected_hub_item() + if item.is_empty() or _hub_running: + return + var owner: Variant = item.get("owner", {}) + var owner_name := "" + if owner is Dictionary: + owner_name = str((owner as Dictionary).get("username", "")) + var current := HubSettings.load_settings() + if ( + owner_name != str(current.get("username", "")) + and str(current.get("role", "")) != "admin" + ): + return + _start_hub_job(HubJob.Task.HIDE, {"id": int(item.get("id", 0))}) + + +func _finish_hub_publish(job: HubJob) -> void: + var title := str(job.result.get("title", "")) + hub_status_label.text = "Im Hub veröffentlicht: " + title + _show_message( + "Kür im Hub veröffentlicht%s.\n\n" + % (" als Revision %s" % str(job.result.get("revision", "1"))) + + "Andere Beta-Konten können sie jetzt unter Datei → Kür-Hub… laden." + ) + _start_hub_list() + + +func _finish_hub_hide(job: HubJob) -> void: + hub_status_label.text = "Kür aus dem Hub genommen." + _show_message("Die Kür wurde aus dem Hub genommen.") + _start_hub_list() + + +func _finish_hub_download(job: HubJob) -> void: + _cleanup_hub_pending() + var routine_name := str(job.result.get("routine_name", "")) + var audio_name := str(job.result.get("audio_name", "")) + if routine_name.is_empty(): + _show_message("Der Hub hat keine Kürdatei geliefert.") + return + var routine_exists := FileAccess.file_exists(ROUTINES_DIR.path_join(routine_name)) + var audio_exists := ( + not audio_name.is_empty() + and FileAccess.file_exists(ROUTINES_DIR.path_join(audio_name)) + ) + _hub_pending_download = job.result + if routine_exists or audio_exists: + hub_conflict_text.text = ( + "Im lokalen Kürordner existiert bereits:\n\n%s\n\n" + % "\n".join(_hub_conflict_lines(routine_name, audio_name)) + + "„Nummerierte Kopie“ legt beide Dateien mit einem Zusatz " + + "„(Hub 2)“ an; „Überschreiben“ ersetzt die vorhandenen Dateien." + ) + hub_conflict_dialog.popup_centered(Vector2i(640, 320)) + return + _apply_hub_download(true) + + +func _hub_conflict_lines(routine_name: String, audio_name: String) -> PackedStringArray: + var lines := PackedStringArray() + if FileAccess.file_exists(ROUTINES_DIR.path_join(routine_name)): + lines.append("• " + routine_name) + if ( + not audio_name.is_empty() + and FileAccess.file_exists(ROUTINES_DIR.path_join(audio_name)) + ): + lines.append("• " + audio_name) + return lines + + +func _on_hub_conflict_copy() -> void: + _apply_hub_download(false) + + +func _on_hub_conflict_action(action: StringName) -> void: + if action == &"overwrite": + _apply_hub_download(true) + + +func _on_hub_conflict_cancel() -> void: + _cleanup_hub_pending() + hub_status_label.text = "Download abgebrochen." + + +func _apply_hub_download(overwrite: bool) -> void: + var pending := _hub_pending_download + _hub_pending_download = {} + if pending.is_empty(): + return + var routine_name := str(pending.get("routine_name", "")) + var audio_name := str(pending.get("audio_name", "")) + var target_routine := routine_name + var target_audio := audio_name + var routine_exists := FileAccess.file_exists(ROUTINES_DIR.path_join(routine_name)) + var audio_exists := ( + not audio_name.is_empty() + and FileAccess.file_exists(ROUTINES_DIR.path_join(audio_name)) + ) + + if overwrite and audio_exists and _hub_audio_used_elsewhere(routine_name, audio_name): + overwrite = false + if not overwrite and (routine_exists or audio_exists): + var numbered := HubClient.numbered_names(ROUTINES_DIR, routine_name, audio_name) + if numbered.is_empty(): + _discard_hub_download(pending) + _show_message("Es konnte kein freier Dateiname gefunden werden.") + return + target_routine = str(numbered.get("routine", routine_name)) + target_audio = str(numbered.get("audio", audio_name)) + + _ensure_routines_dir() + var source_routine := str(pending.get("routine_path", "")) + if target_audio != audio_name: + var rewrite_error := _rewrite_hub_music_file(source_routine, target_audio) + if not rewrite_error.is_empty(): + _discard_hub_download(pending) + _show_message(rewrite_error) + return + + var move_error := _move_hub_file( + source_routine, + ROUTINES_DIR.path_join(target_routine), + overwrite + ) + if move_error.is_empty() and not str(pending.get("audio_path", "")).is_empty(): + move_error = _move_hub_file( + str(pending.get("audio_path", "")), + ROUTINES_DIR.path_join(target_audio), + overwrite + ) + if not move_error.is_empty(): + _discard_hub_download(pending) + _show_message("Kür konnte nicht gespeichert werden:\n\n" + move_error) + return + + _discard_hub_download(pending) + hub_status_label.text = "Vom Hub geladen: " + target_routine + _refresh_open_list() + if routine_manager_dialog.visible: + _refresh_routine_manager() + _show_message( + "Kür vom Hub geladen:\n\n%s\n\n" + % target_routine + + "Du findest sie unter Datei → Öffnen…" + ) + + +func _rewrite_hub_music_file(path: String, audio_name: String) -> String: + var text := FileAccess.get_file_as_string(path) + if text.is_empty(): + return "Die heruntergeladene Kürdatei ist leer." + var data: Variant = JSON.parse_string(text) + if not data is Dictionary: + return "Die heruntergeladene Kürdatei ist kein gültiges JSON." + (data as Dictionary)["music_file"] = audio_name + var file := FileAccess.open(path, FileAccess.WRITE) + if file == null: + return "Die Kürdatei konnte nicht angepasst werden." + file.store_string(JSON.stringify(data, "\t", false, true)) + file.close() + return "" + + +func _move_hub_file(source: String, target: String, overwrite: bool) -> String: + if not FileAccess.file_exists(source): + return "Quelldatei fehlt: " + source.get_file() + var absolute_source := ProjectSettings.globalize_path(source) + var absolute_target := ProjectSettings.globalize_path(target) + if FileAccess.file_exists(target): + if not overwrite: + return "Ziel existiert bereits: " + target.get_file() + DirAccess.remove_absolute(absolute_target) + var error := DirAccess.rename_absolute(absolute_source, absolute_target) + if error == OK: + return "" + error = DirAccess.copy_absolute(absolute_source, absolute_target) + if error != OK: + return "Datei konnte nicht verschoben werden (Fehler %d): %s" % [ + error, + target.get_file(), + ] + DirAccess.remove_absolute(absolute_source) + return "" + + +func _hub_audio_used_elsewhere(routine_name: String, audio_name: String) -> bool: + for file: String in _routine_entries(): + if file == routine_name: + continue + var music := RoutineFile.read_music_file(ROUTINES_DIR.path_join(file)) + if music == audio_name: + return true + return false + + +func _cleanup_hub_pending() -> void: + _discard_hub_download(_hub_pending_download) + _hub_pending_download = {} + + +func _discard_hub_download(pending: Dictionary) -> void: + HubClient.clear_pending(str(pending.get("folder", ""))) + + func _start_google_login(app: Dictionary) -> void: _abort_oauth_job() _oauth_provider = "google_drive" @@ -6372,6 +7056,9 @@ func _exit_tree() -> void: if _sync_thread != null: _sync_thread.wait_to_finish() _sync_thread = null + if _hub_thread != null: + _hub_thread.wait_to_finish() + _hub_thread = null func _open_export_dialog() -> void: diff --git a/rinkplanner/tests/run_hub_tests.gd b/rinkplanner/tests/run_hub_tests.gd new file mode 100644 index 0000000..ae17ca1 --- /dev/null +++ b/rinkplanner/tests/run_hub_tests.gd @@ -0,0 +1,403 @@ +extends SceneTree + +## Headless tests for the Kür-Hub client: settings/token handling, URL +## normalization, collision names, API error mapping and the settings/menu +## wiring. No network access is required. + +const WhiteboardScene := preload("res://scenes/whiteboard/whiteboard.tscn") +const TEST_DIR := "user://hub-test" + +var _assertions: int = 0 +var _failures: PackedStringArray = PackedStringArray() + + +func _init() -> void: + _run.call_deferred() + + +func _run() -> void: + _test_settings() + _test_url_normalization() + _test_numbered_names() + _test_error_messages() + await _test_controller_wiring() + HubSettings.clear_settings() + _remove_test_dir() + _finish() + + +func _test_settings() -> void: + HubSettings.clear_settings() + var defaults := HubSettings.load_settings() + _check( + not HubSettings.is_linked(defaults), + "ohne Token ist der Hub nicht verbunden" + ) + _check( + str(defaults.get("base_url", "")).begins_with("https://"), + "die Standard-Hub-Adresse nutzt HTTPS" + ) + + var token := "rhub_" + "a".repeat(64) + _check(HubSettings.is_token_valid(token), "ein rhub_-Token gilt als gültig") + _check( + not HubSettings.is_token_valid("rhub_kurz"), + "zu kurze Tokens werden abgelehnt" + ) + _check( + not HubSettings.is_token_valid("bearer " + token), + "Tokens ohne rhub_-Präfix werden abgelehnt" + ) + + var settings := { + "base_url": "https://rinkplanner-hub.programmschmiede.de", + "token": token, + "username": "tester", + "role": "user", + "verified": true, + } + HubSettings.save_settings(settings) + var loaded := HubSettings.load_settings() + _check(HubSettings.is_linked(loaded), "gespeicherte Verbindung gilt als verbunden") + _check(loaded.get("username") == "tester", "der Kontoname wird gespeichert") + _check(loaded.get("token") == token, "der Token wird gespeichert") + + var unverified := HubSettings.mark_unverified(loaded) + _check( + not HubSettings.is_linked(unverified), + "ein widerrufener Token trennt den Hub" + ) + _check( + unverified.get("token") == token, + "beim Trennen bleibt der Token zum erneuten Prüfen erhalten" + ) + var forgotten := HubSettings.forget_token(unverified) + _check( + str(forgotten.get("token", "")).is_empty(), + "Trennen entfernt den Token" + ) + _check( + not HubSettings.is_linked(forgotten), + "nach dem Trennen ist der Hub nicht verbunden" + ) + HubSettings.clear_settings() + + +func _test_url_normalization() -> void: + _check( + HubSettings.normalize_url("rinkplanner-hub.example.org/") + == "https://rinkplanner-hub.example.org", + "Adressen bekommen HTTPS und verlieren den Schrägstrich" + ) + _check( + HubSettings.normalize_url("https://hub.example.org/api/v1") + == "https://hub.example.org", + "ein eingefügter API-Pfad wird entfernt" + ) + _check( + HubSettings.normalize_url("") + == HubSettings.DEFAULT_URL, + "eine leere Adresse fällt auf den Standard zurück" + ) + + +func _test_numbered_names() -> void: + _remove_test_dir() + DirAccess.make_dir_recursive_absolute(TEST_DIR) + _write_text(TEST_DIR.path_join("kuer.json"), "{}") + _write_text(TEST_DIR.path_join("musik.mp3"), "audio") + var names := HubClient.numbered_names(TEST_DIR, "kuer.json", "musik.mp3") + _check( + names.get("routine") == "kuer (Hub 2).json", + "die Kür bekommt eine nummerierte Kopie" + ) + _check( + names.get("audio") == "musik (Hub 2).mp3", + "die Musik bekommt dieselbe Nummer" + ) + _write_text(TEST_DIR.path_join("kuer (Hub 2).json"), "{}") + _write_text(TEST_DIR.path_join("musik (Hub 2).mp3"), "audio") + var next := HubClient.numbered_names(TEST_DIR, "kuer.json", "musik.mp3") + _check( + next.get("routine") == "kuer (Hub 3).json", + "belegte Nummern werden übersprungen" + ) + _remove_test_dir() + + +func _test_error_messages() -> void: + _check( + HubClient.error_message({}, 401).contains("abgelaufen"), + "401 erklärt die abgelaufene Verbindung" + ) + var validation := { + "error": {"code": "validation_failed", "message": "Ungültig."}, + "errors": ["Kür fehlt", "Musik fehlt"], + } + var message := HubClient.error_message(validation, 422) + _check( + message.contains("Ungültig.") and message.contains("Kür fehlt"), + "422 zeigt Detailfehler" + ) + _check( + HubClient.error_message( + {"error": {"code": "duplicate", "message": "Schon da."}}, + 409 + ) == "Schon da.", + "409 übernimmt die Servermeldung" + ) + _check( + HubClient.error_message({}, 429).contains("Anfragen"), + "429 erklärt das Limit" + ) + + +func _test_controller_wiring() -> void: + HubSettings.clear_settings() + var scene := WhiteboardScene.instantiate() + var controller := scene as WhiteboardController + controller.restore_autosave = false + controller.autosave_enabled = false + root.add_child(scene) + await process_frame + if controller == null: + return + + controller._refresh_hub_menu() + _check( + _find_menu_item(controller, "Kür-Hub…") < 0, + "ohne Hub-Verbindung fehlt der Menüpunkt" + ) + + var token := "rhub_" + "b".repeat(64) + HubSettings.save_settings({ + "base_url": "https://rinkplanner-hub.example.org", + "token": token, + "username": "tester", + "role": "user", + "verified": true, + }) + controller._refresh_hub_menu() + _check( + _find_menu_item(controller, "Kür-Hub…") >= 0, + "mit Verbindung erscheint der Hub im Dateimenü" + ) + + controller._open_sync_settings_dialog() + _check( + controller.hub_url_edit.text == "https://rinkplanner-hub.example.org", + "die Sync-Einstellungen zeigen die Hub-Adresse" + ) + _check( + controller.hub_token_edit.text == token, + "die Sync-Einstellungen zeigen den Token" + ) + _check( + controller.hub_account_value.text.contains("tester"), + "die Sync-Einstellungen zeigen das Hub-Konto" + ) + _check( + controller.hub_connect_button.text == "Trennen", + "ein verbundenes Konto bietet Trennen an" + ) + controller.sync_settings_dialog.hide() + + var items: Array[Dictionary] = [ + { + "id": 7, + "title": "Testkür", + "skater_name": "Läuferin", + "revision": 2, + "routine_bytes": 2048, + "audio_bytes": 4096, + "owner": {"username": "andere", "display_name": "Andere"}, + }, + { + "id": 8, + "title": "Eigene Kür", + "skater_name": "Ich", + "revision": 1, + "routine_bytes": 1024, + "audio_bytes": null, + "owner": {"username": "tester", "display_name": "Tester"}, + }, + ] + controller._hub_items = items + controller._populate_hub_tree() + var tree := controller.hub_tree + _check( + tree.get_root() != null and tree.get_root().get_child_count() == 2, + "der Hub-Dialog listet beide Küren" + ) + var first := tree.get_root().get_child(0) + first.select(0) + controller._on_hub_tree_selected() + _check( + not controller.hub_download_button.disabled, + "eine fremde Kür lässt sich herunterladen" + ) + _check( + controller.hub_hide_button.disabled, + "fremde Küren lassen sich nicht aus dem Hub nehmen" + ) + _check( + controller.hub_detail_label.text.contains("Testkür") + and controller.hub_detail_label.text.contains("andere"), + "die Detailzeile nennt Kür und Eigentümer" + ) + var second := tree.get_root().get_child(1) + second.select(0) + controller._on_hub_tree_selected() + _check( + not controller.hub_hide_button.disabled, + "eigene Küren lassen sich aus dem Hub nehmen" + ) + _check( + controller._hub_size_label(items[0]) == "6 KB", + "die Größe wird aus Kür und Musik summiert" + ) + _test_download_integration(controller) + + HubSettings.clear_settings() + controller._refresh_hub_menu() + _check( + _find_menu_item(controller, "Kür-Hub…") < 0, + "nach dem Trennen verschwindet der Menüpunkt wieder" + ) + scene.queue_free() + await process_frame + + +func _test_download_integration(controller: WhiteboardController) -> void: + var routines := RoutineSync.LOCAL_DIR + DirAccess.make_dir_recursive_absolute(routines) + _remove_routine_test_files(routines) + var pending := "user://hub-pending-test" + _remove_test_dir_at(pending) + DirAccess.make_dir_recursive_absolute(pending) + + _write_text(routines.path_join("kuer.json"), _routine_json("Bestehend", "musik.mp3")) + _write_text(routines.path_join("musik.mp3"), "lokal") + _write_text(pending.path_join("kuer.json"), _routine_json("Vom Hub", "musik.mp3")) + _write_text(pending.path_join("musik.mp3"), "hub-audio") + controller._hub_pending_download = { + "folder": pending, + "routine_name": "kuer.json", + "audio_name": "musik.mp3", + "routine_path": pending.path_join("kuer.json"), + "audio_path": pending.path_join("musik.mp3"), + } + controller._apply_hub_download(false) + controller.message_dialog.hide() + var numbered := routines.path_join("kuer (Hub 2).json") + var numbered_audio := routines.path_join("musik (Hub 2).mp3") + _check(FileAccess.file_exists(numbered), "Kollisionen erzeugen eine nummerierte Kür") + _check(FileAccess.file_exists(numbered_audio), "die Musik wird mitnummeriert") + var rewritten: Variant = JSON.parse_string(FileAccess.get_file_as_string(numbered)) + _check( + rewritten is Dictionary + and str((rewritten as Dictionary).get("music_file", "")) == "musik (Hub 2).mp3", + "die Kür verweist nach dem Umbenennen auf die neue Musik" + ) + _check( + FileAccess.get_file_as_string(routines.path_join("kuer.json")).contains("Bestehend"), + "die vorhandene Kür bleibt beim nummerierten Kopieren unverändert" + ) + + var overwrite_pending := "user://hub-pending-overwrite" + _remove_test_dir_at(overwrite_pending) + DirAccess.make_dir_recursive_absolute(overwrite_pending) + _write_text(overwrite_pending.path_join("kuer.json"), _routine_json("Überschrieben", "musik.mp3")) + _write_text(overwrite_pending.path_join("musik.mp3"), "neu") + controller._hub_pending_download = { + "folder": overwrite_pending, + "routine_name": "kuer.json", + "audio_name": "musik.mp3", + "routine_path": overwrite_pending.path_join("kuer.json"), + "audio_path": overwrite_pending.path_join("musik.mp3"), + } + controller._apply_hub_download(true) + controller.message_dialog.hide() + _check( + FileAccess.get_file_as_string(routines.path_join("kuer.json")).contains("Überschrieben"), + "Überschreiben ersetzt die vorhandene Kür" + ) + _check( + FileAccess.get_file_as_string(routines.path_join("musik.mp3")) == "neu", + "Überschreiben ersetzt die vorhandene Musik" + ) + _remove_routine_test_files(routines) + _remove_test_dir_at(pending) + _remove_test_dir_at(overwrite_pending) + + +func _routine_json(title: String, music: String) -> String: + return JSON.stringify({ + "format": "rinkplanner.routine", + "format_version": 1, + "schema_version": 1, + "routine_id": "hub-test", + "title": title, + "music_file": music, + "sections": [], + }, "\t", false, true) + + +func _remove_routine_test_files(routines: String) -> void: + for name: String in [ + "kuer.json", "kuer (Hub 2).json", "kuer (Hub 3).json", + "musik.mp3", "musik (Hub 2).mp3", "musik (Hub 3).mp3", + ]: + var path := routines.path_join(name) + if FileAccess.file_exists(path): + DirAccess.remove_absolute(ProjectSettings.globalize_path(path)) + + +func _remove_test_dir_at(path: String) -> void: + var folder := ProjectSettings.globalize_path(path) + if not DirAccess.dir_exists_absolute(folder): + return + for file: String in DirAccess.get_files_at(folder): + DirAccess.remove_absolute(folder.path_join(file)) + DirAccess.remove_absolute(folder) + + +func _find_menu_item(controller: WhiteboardController, text: String) -> int: + var popup := controller.file_menu_button.get_popup() + for index: int in range(popup.item_count): + if popup.get_item_text(index) == text: + return index + return -1 + + +func _write_text(path: String, text: String) -> void: + var file := FileAccess.open(path, FileAccess.WRITE) + if file != null: + file.store_string(text) + file.close() + + +func _remove_test_dir() -> void: + var folder := ProjectSettings.globalize_path(TEST_DIR) + if not DirAccess.dir_exists_absolute(folder): + return + for file: String in DirAccess.get_files_at(folder): + DirAccess.remove_absolute(folder.path_join(file)) + DirAccess.remove_absolute(folder) + + +func _check(condition: bool, message: String) -> void: + _assertions += 1 + if not condition: + _failures.append(message) + + +func _finish() -> void: + if _failures.is_empty(): + print("PASS: %d assertions" % _assertions) + quit(0) + else: + for failure: String in _failures: + printerr("FAIL: " + failure) + printerr("%d of %d assertions failed" % [_failures.size(), _assertions]) + quit(1) diff --git a/rinkplanner/tests/run_hub_tests.gd.uid b/rinkplanner/tests/run_hub_tests.gd.uid new file mode 100644 index 0000000..f8ddb6b --- /dev/null +++ b/rinkplanner/tests/run_hub_tests.gd.uid @@ -0,0 +1 @@ +uid://eyveg5lvk1vc diff --git a/tools/test.sh b/tools/test.sh index f0cdbbd..c9804af 100755 --- a/tools/test.sh +++ b/tools/test.sh @@ -75,6 +75,9 @@ fi "$GODOT" --headless --path "$PROJECT_DIR" \ --script res://tests/run_sync_tests.gd +"$GODOT" --headless --path "$PROJECT_DIR" \ + --script res://tests/run_hub_tests.gd + "$GODOT" --headless --path "$PROJECT_DIR" \ --script res://tests/run_asset_manifest_tests.gd