feat: Cloud-Sync über Dropbox und Google Drive

- 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
This commit is contained in:
torsten 2026-11-09 06:25:21 +01:00
parent 533a12ef1a
commit 74d9d6b61f
36 changed files with 3040 additions and 817 deletions

View file

@ -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()

View file

@ -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

View file

@ -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 ""

View file

@ -0,0 +1 @@
uid://bh2kwi34xujd1

View file

@ -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"

View file

@ -0,0 +1 @@
uid://buoubgak6d4pf

View file

@ -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",
})

View file

@ -0,0 +1 @@
uid://b33i7cyu0wjtf

View file

@ -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))

View file

@ -0,0 +1 @@
uid://kjceh3wa2e22

View file

@ -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", " ")

View file

@ -1 +0,0 @@
uid://3n477aydpya3

View file

@ -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

View file

@ -0,0 +1 @@
uid://drj84omv865yc

View file

@ -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

View file

@ -0,0 +1 @@
uid://cbvjyx473huoq

View file

@ -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

View file

@ -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

View file

@ -0,0 +1 @@
uid://d0h7eoxsm5r1w

View file

@ -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

View file

@ -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:

View file

@ -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

View file

@ -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=""

View file

@ -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
```

View file

@ -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"

View file

@ -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()