diff --git a/CHANGELOG.md b/CHANGELOG.md index cd94681..57b873c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -236,6 +236,129 @@ Vor dem Push ein Review über den gesamten Diff der Blur-Übergang-Serie - ✅ **Getestet:** 3 neue Widget-Tests (RED→GREEN, je einer pro Stelle), volle Suite (590 Tests) grün, `flutter analyze` ohne Befund. +### 🐛 Cloud-Kontingent-Fix aus dem Task-Review (2026-08-29) + +- 🔁 **`BakaAuth.abmelden()` setzt jetzt auch `verbleibend` zurück.** + Referenzmuster `GastZugang.verwerfen()` setzt `_verbleibend = null` mit, + `abmelden()` tat das bisher nicht — nur `_token`/`_benutzer` wurden + zurückgesetzt. Meldet sich ein Cloud-User ab und ein ANDERER Cloud-User + (Dustin/Baka/Tinker) danach an, wäre sonst bis zum nächsten Download der + alte Kontingent-Stand des vorherigen Accounts sichtbar geblieben. + Aktuell folgenlos (da `verbleibend` bis zum Server-Rollout ohnehin immer + `null` ist), aber ein latenter Bug, der beim Server-Rollout live + gegangen wäre. (`lib/services/baka_auth.dart`) +- ✅ **Getestet (RED→GREEN):** neuer Test „Abmelden setzt auch den + Kontingent-Stand zurück" in `test/services/baka_auth_test.dart`. Volle + Suite grün, `flutter analyze` ohne Befund. + +### ☁️ Cloud-Account-Kontingent: App-Seite für das 100/Tag-Limit (2026-08-29) + +- ⚠️ **Reine App-Seite, ohne Wirkung bis der Server mitzieht.** Die + Server-Zählung (`cloud_quota`, 100/Tag je Nutzername) in `yt_proxy.py` + ist NICHT Teil dieser Änderung — das macht die `claude-server`-Session + separat (siehe Nachtrag "100/Tag-Limit auch für Cloud-Accounts" in + `docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md`). Bis + der Server das neue Feld `cloud_remaining` liefert, bleibt + `auth.verbleibend` einfach `null` — kein Fehler, kein sichtbarer + Unterschied zu heute. +- 🔢 **`BakaAuth` bekommt einen Kontingent-Stand** — analog zu + `GastZugang.verbleibend`/`.merkeVerbleibend(n)`: neues Feld `int? + verbleibend` (Getter) und `void merkeVerbleibend(int n)` + (`lib/services/baka_auth.dart`). +- 🔌 **`YtDownloadService.herunterladen()` liest `cloud_remaining`** aus + einer erfolgreichen `POST /api/yt-dl`-Antwort und ruft bei + Cloud-Zugriff (`!gastAktiv`) `auth.merkeVerbleibend(...)` auf — genau + wie beim bestehenden `guest_remaining`/`gast.merkeVerbleibend(...)` + fürs Gast-Kontingent, aber strikt getrennt (ein Gast-Zugriff liest das + Feld nie, ein Cloud-Zugriff nie `guest_remaining`). + (`lib/services/yt_download_service.dart`) +- 📟 **Angemeldete Cloud-Accounts sehen jetzt „Noch N von 100 heute“**, + sobald der Server den Stand gemeldet hat — an vergleichbarer Stelle wie + der bestehende Gast-Zähler, aber nur bei `auth.istAngemeldet` (Gäste + haben weiter ihren eigenen Text, beide schließen sich gegenseitig aus). + (`lib/downloads/downloads_screen.dart`, + `lib/downloads/youtube_search_screen.dart`) +- ✅ **Getestet (TDD, RED→GREEN):** `merkeVerbleibend` in + `test/services/baka_auth_test.dart`; Erfolgsfall mit `cloud_remaining` + plus eine Trennschärfe-Gegenprobe (Gast-Zugriff liest `cloud_remaining` + nie, selbst wenn es im Body steht) in + `test/services/yt_download_test.dart`; je ein Widget-Test für den neuen + „Noch N von 100 heute“-Text in `test/downloads/online_screen_test.dart` + und `test/downloads/youtube_search_screen_test.dart`. Volle Suite + grün, `flutter analyze` ohne Befund. + +### 🐛 Gast-Zugang: Fixe aus dem Branch-Abschluss-Review (2026-08-26) + +- 🔓 **Gast-Modus war eine Einbahnstraße.** Einmal "Als Gast fortfahren" + angetippt, blieb `gast.hatToken` dauerhaft `true` (Token steckt im + Secure Storage, wird bei jedem App-Start wiederhergestellt) — und damit + war `_AnmeldeDialog`, der EINZIGE Einstieg in der App für die + Baka-Anmeldung (auch für den Melo-Cloud-Sync-Login!), unerreichbar. + Neu: `GastZugang.verwerfen()` verwirft den Token wieder, und ein + "Anmelden"-Knopf neben der Gast-Statuszeile (Download-Tab und + YT-Suche-Tab) ruft ihn auf. +- 🔀 **Ein alter Gast-Token hat den Auto-Login-Rückfallweg für + Server-User verdeckt.** `zugriffOk` prüfte bisher den rohen + `gast.hatToken` statt `istGastModus` — ein Gerät, das früher mal als + Gast lief und jetzt als Server-User mit fehlgeschlagenem Auto-Login + dasteht, bekam die Fehlermeldung dazu nie zu sehen und lud still über + den (limitierten) Gast-Pfad. `istGastModus` wird jetzt vor `zugriffOk` + berechnet und dort statt des rohen Tokens verwendet. + (`lib/downloads/downloads_screen.dart`, + `lib/downloads/youtube_search_screen.dart`) +- ⏱️ **Doppel-Tap auf "Als Gast fortfahren" konnte zwei Anfragen + gleichzeitig auslösen.** Beide Screens sperren den Button jetzt während + `holeToken()` läuft (`_gastLaeuft`). +- 📝 **Widersprüchlicher Hinweistext im YT-Suche-Tab behoben** — der Text + über dem Gast-Button verlangte fälschlich eine Baka-Anmeldung. +- ⚠️ **CHANGELOG ergänzt:** der Abschnitt zum Gast-Zugang unten macht jetzt + klar, dass die Server-Seite (`POST /api/guest-token`) noch fehlt. +- ✅ **Getestet:** 2 neue Regressionstests fürs "Anmelden"-Escape-Hatch + (`test/downloads/online_screen_test.dart`, + `test/downloads/youtube_search_screen_test.dart`), 2 bestehende Gast-Tests + im YT-Suche-Tab jetzt mit echtem `gast:`-Wiring in + `YtSearchService`/`YtDownloadService`. Volle Suite grün, `flutter + analyze` ohne Befund. + +### 📺👤 YouTube-Gast-Zugang: bewusste Wahl + Tages-Zähler (Download-Tab + YT-Suche-Tab) (2026-08-26) + +- ⚠️ **Braucht noch die Server-Seite.** Der neue Endpunkt `POST + /api/guest-token` und die Quota-Logik in `yt_proxy.py` existieren noch + nicht (separates Vorhaben, siehe + `docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md`). Bis + die Server-Seite steht, liefert der "Als Gast fortfahren"-Button + zuverlässig einen 404-Fehler. +- 👤 **Echte Gäste (kein Baka-Konto, kein Melo-Server) sehen jetzt zwei + Buttons** statt nur der Anmeldung: "Beim Baka-Konto anmelden" und neu + "Als Gast fortfahren (5 Downloads/Tag)". Der Gast-Button holt sich per + `GastZugang.holeToken()` (aus Task 1-4 dieser Reihe) einen anonymen + Token vom Proxy und schaltet damit den Downloader frei — ganz ohne + Konto. Schlägt das Holen fehl, erscheint der Fehlertext direkt unter + dem Button. +- 🔢 **Im Gast-Modus zeigt eine Statuszeile "Als Gast unterwegs — noch N + von 5 heute"**, sobald der Server den Kontingent-Stand gemeldet hat + (vorher nur der generische Hinweistext "5 Downloads/Tag"). Der + Cookie-Schalter ("YouTube-Cookies des Servers verwenden") ist im + Gast-Modus ausgeblendet — der Server erzwingt für Gast-Zugriffe ohnehin + `cookies=false`, ein sichtbarer Schalter hätte nur eine Wahl vorgetäuscht, + die es nicht gibt. +- 🐛 **Nebenbefund durchs Qualitäts-Gate:** `_YouTubeBereich.build()` + beobachtet jetzt `GastZugang` app-weit über den Provider-Baum. Zwei + Tests (`hauptmenue_test.dart`, `home_shell_test.dart`) bauen ihren + eigenen Provider-Baum nach, statt `main.dart` zu importieren, und + hatten `GastZugang` dort noch nicht — beide entsprechend ergänzt (analog + zum bestehenden Muster für `BakaAuth`/`YtDownloadService`). +- 📺 **YT-Suche-Tab bekommt denselben Gast-Button und -Zähler** wie der + Download-Tab. Das alte "Baka-Anmeldung (siehe Download-Tab)" Hint für + Gäste ist weg — echte Gäste in `lib/downloads/youtube_search_screen.dart` + sehen jetzt "Als Gast fortfahren (5 Downloads/Tag)" und die Status-Zeile + "Als Gast unterwegs — noch N von 5 heute", genauso wie im Download-Tab. +- ✅ **Getestet:** volle Suite grün (600 Tests), `flutter analyze` ohne + Befund. 3 neue Widget-Tests in + `test/downloads/online_screen_test.dart`: beide Buttons sichtbar, + Gast-Token-Erfolg schaltet das Adressfeld frei, Gast-Token-Fehler wird + angezeigt. + ### 📺🔑 YouTube-Tab: Server-User brauchen keine eigene Baka-Anmeldung mehr (2026-08-26) - 🔑 **Server-User (Dustin, Baka, Tinker) sehen den Baka-Anmelde-Schritt nicht diff --git a/docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md b/docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md index bcc935d..bf82cfb 100644 --- a/docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md +++ b/docs/superpowers/specs/2026-08-26-youtube-guest-quota-design.md @@ -50,17 +50,97 @@ vorbehalten. | Reset-Zeitpunkt | Kalendertag nach Server-Zeit (Aingrad), kein rollierendes 24h-Fenster | | Suche fürs Limit | Suche bleibt für Gäste unbegrenzt — nur `POST /api/yt-dl` zählt | | Cookies für Gäste | Nein — nur Cloud-Accounts bekommen Dustins YouTube-Cookies; der `cookies`-Parameter wird bei Gast-Token-Anfragen ignoriert | +| Limit für Cloud-Accounts | **Nachtrag 2026-08-29:** 100 Downloads/Kalendertag je Nutzer (Dustin/Baka/Tinker je einzeln gezählt) — ersetzt das ursprüngliche „kein Limit". Grund: dieselbe Absicherung wie beim Gast-Limit, nur großzügiger, da Cloud-Accounts vertraute Nutzer mit Cookie-Zugriff sind. | ## Architektur Drei Zugangsklassen beim Proxy: -1. **Cloud-Account** (`Authorization: Bearer `, wie heute) — unbegrenzt, - Cookies automatisch. +1. **Cloud-Account** (`Authorization: Bearer `, wie heute) — **100 + Downloads/Kalendertag je Nutzer** (Nachtrag 2026-08-29, ersetzt + „unbegrenzt"), Cookies automatisch, Suche unbegrenzt (wie bei Gästen). 2. **Gast** (`X-Guest-Token: `, neu) — 5 Downloads/Kalendertag, Suche unbegrenzt, keine Cookies. 3. **Kein Zugang** — weder Bearer noch gültiger Gast-Token → 401 wie heute. +## Nachtrag 2026-08-29: 100/Tag-Limit auch für Cloud-Accounts + +Dustin hat beim erneuten Durchsprechen der Architektur (nach den +Login-Race-Fixes) bestätigt, dass auch Cloud-Accounts (Dustin, Baka, +Tinker) ein Tages-Limit bekommen sollen — 100 statt der ursprünglich +geplanten 5, aber nicht mehr unbegrenzt. Grund: dieselbe +Missbrauchs-/Kosten-Absicherung wie beim Gast-Limit (YouTube-Rate-Limits, +Serverlast), nur mit großzügigerem Kontingent, weil Cloud-Accounts +vertraute, bekannte Nutzer sind und zusätzlich Cookie-Zugriff haben. + +**Übernommene Entscheidungen des Gast-Limits (analog, keine neue +Diskussion nötig):** Reset zum Kalendertag (Server-Zeit), Suche zählt +nicht, nur `POST /api/yt-dl` zählt, Klartext-429-Fehlermeldung ohne +automatischen Retry. + +**Unterschied zum Gast-Limit:** Cloud-Accounts zählen **pro Nutzername** +(aus dem verifizierten JWT), nicht pro Gerät/Token — ein Nutzer, der die +App auf zwei Geräten installiert hat, teilt sich also ein gemeinsames +Kontingent (folgerichtig, da derselbe Baka-Account). + +### Server-seitige Änderungen (zusätzlich zu den bestehenden Abschnitten oben — Hermes/`claude-server`-Worktree) + +- Neue Tabelle (oder Erweiterung von `guest_quota`, falls strukturell + identisch — Entscheidung liegt bei der Server-Session) analog zu + `guest_quota`, aber mit `username` statt `token` als Schlüssel: + ```sql + CREATE TABLE IF NOT EXISTS cloud_quota ( + username TEXT PRIMARY KEY, + count INTEGER NOT NULL DEFAULT 0, + count_date TEXT NOT NULL + ); + ``` +- `POST /api/yt-dl` bei Cloud-Zugriff (gültiger Bearer-JWT): dieselbe + Tageswechsel-Reset-Logik wie bei Gästen, aber Schlüssel = Nutzername aus + dem JWT. Bei `count >= 100` → `429` mit + `{"error": "Tages-Limit erreicht (100/Tag) — ab morgen wieder verfügbar", "cooldown": }`. + Erfolgsantwort bekommt zusätzlich `"cloud_remaining": ` (nur bei + Cloud-Zugriff, analog zu `guest_remaining` bei Gästen — beide Felder + schließen sich gegenseitig aus, nie beide gleichzeitig gesetzt). +- `GET /api/search` bleibt für Cloud-Accounts unverändert unbegrenzt (wie + für Gäste). + +### App-seitige Änderungen (diese Seite implementiere ich) + +- `BakaAuth` (`lib/services/baka_auth.dart`) bekommt — analog zu + `GastZugang.verbleibend`/`.merkeVerbleibend(n)` — ein neues Feld + `int? verbleibend` (Getter) und `void merkeVerbleibend(int n)`, das den + zuletzt vom Server gemeldeten Kontingent-Stand hält (nur fürs Anzeigen, + `null` vor dem ersten Download in dieser Session). +- `YtDownloadService.herunterladen()` (`lib/services/yt_download_service.dart`): + liest nach einem erfolgreichen `POST /api/yt-dl` zusätzlich + `daten['cloud_remaining']` aus, und ruft bei `!gastAktiv` (also + Cloud-Zugriff) `auth.merkeVerbleibend(cloudRest)` auf — analog zur + bestehenden `gast!.merkeVerbleibend(gastRest)`-Zeile. Ein `429` läuft + bereits durch den bestehenden generischen `_fehlerText(antwort)`-Pfad + (kein neuer Fehlerfall nötig, der zeigt jeden Server-`error`-Text aus dem + 200-fremden Statuscode an — funktioniert für 429 genauso wie für 401 + außerhalb des Spezialfalls). +- UI (`_YouTubeBereich` in `lib/downloads/downloads_screen.dart`, + `YoutubeSearchScreen` in `lib/downloads/youtube_search_screen.dart`): + zeigt analog zum bestehenden Gast-Text („Als Gast unterwegs — noch N von + 5 heute") jetzt auch für angemeldete Cloud-Accounts einen Text „Noch N + von 100 heute", sobald `auth.verbleibend != null` — platziert an + vergleichbarer Stelle wie der Gast-Text, aber nur sichtbar wenn + `auth.istAngemeldet` (nicht für Gäste, die haben ihren eigenen Text). + +### Tests (Nachtrag) + +- **App:** `BakaAuth.merkeVerbleibend`, `YtDownloadService` liest + `cloud_remaining` bei Cloud-Zugriff (nicht bei Gast-Zugriff — die beiden + Felder dürfen sich nicht vermischen), Widget-Test für den neuen + „Noch N von 100 heute"-Text in beiden Bildschirmen. +- **Server** (Hermes): analog zu den bestehenden Gast-Tests, plus ein Test, + der sicherstellt, dass Gast- und Cloud-Kontingente unabhängig + voneinander gezählt werden (ein Cloud-Login verbraucht kein + Gast-Kontingent und umgekehrt — sie sind ohnehin durch unterschiedliche + Auth-Wege getrennt, aber das schadet nicht, explizit zu testen). + ## Server-seitige Komponenten **Betrifft `/home/dustin/scripts/yt_proxy.py` und ggf. `auth_common.py` — diff --git a/lib/downloads/downloads_screen.dart b/lib/downloads/downloads_screen.dart index 8fbdce1..c4599a0 100644 --- a/lib/downloads/downloads_screen.dart +++ b/lib/downloads/downloads_screen.dart @@ -11,6 +11,7 @@ import '../player/audio_handler.dart'; import '../services/baka_auth.dart'; import '../services/media_store.dart'; import '../services/download_service.dart'; +import '../services/gast_zugang.dart'; import '../services/navidrome_service.dart'; import '../services/server_neuheiten.dart'; import '../services/yt_download_service.dart'; @@ -615,6 +616,12 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { /// sichtbar, sonst käme so ein User nie mehr an den Dialog heran. bool _autoLoginFehlgeschlagen = false; + /// Fehlertext, falls das Holen des Gast-Tokens scheitert. + String? _gastFehler; + + /// Verhindert Mehrfach-Anfragen bei schnellem Doppel-Antippen. + bool _gastLaeuft = false; + @override void initState() { super.initState(); @@ -686,6 +693,21 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { ); } + Future _alsGastFortfahren() async { + if (_gastLaeuft) return; + final gast = context.read(); + setState(() { + _gastFehler = null; + _gastLaeuft = true; + }); + final fehler = await gast.holeToken(); + if (!mounted) return; + setState(() { + _gastLaeuft = false; + if (fehler != null) _gastFehler = fehler; + }); + } + Future _herunterladen() async { final dienst = context.read(); final lib = context.read(); @@ -737,13 +759,17 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { @override Widget build(BuildContext context) { final auth = context.watch(); + final gast = context.watch(); final dienst = context.watch(); // Server-User gelten sofort als berechtigt — die Anmeldung passiert für // sie im Hintergrund (_pruefeServerUser). Nur wenn die automatische // Anmeldung nachweislich fehlgeschlagen ist, bleibt der manuelle Weg // als Rückfalloption sichtbar — sonst gäbe es keinen Weg mehr zurück. - final zugriffOk = - auth.istAngemeldet || (_serverUser && !_autoLoginFehlgeschlagen); + // Ein Gast-Token zählt ebenfalls als Zugang, nur mit Tages-Limit. + final istGastModus = !_serverUser && !auth.istAngemeldet && gast.hatToken; + final zugriffOk = auth.istAngemeldet || + (_serverUser && !_autoLoginFehlgeschlagen) || + istGastModus; return ListView( padding: const EdgeInsets.fromLTRB(16, 12, 16, 24), @@ -770,8 +796,26 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { onPressed: _anmelden, ), ), - ] else ...[ if (!_serverUser) ...[ + const SizedBox(height: 8), + SizedBox( + width: double.infinity, + height: MeloTheme.minTouchTarget + 4, + child: OutlinedButton.icon( + icon: const Icon(Icons.person_outline), + label: const Text('Als Gast fortfahren (5 Downloads/Tag)', + style: TextStyle(fontSize: 16)), + onPressed: _gastLaeuft ? null : _alsGastFortfahren, + ), + ), + if (_gastFehler != null) ...[ + const SizedBox(height: 8), + Text(_gastFehler!, + style: const TextStyle(color: MeloTheme.red, fontSize: 13)), + ], + ], + ] else ...[ + if (!_serverUser && auth.istAngemeldet) ...[ Row( children: [ const Icon(Icons.verified_user, size: 18, color: MeloTheme.text3), @@ -788,6 +832,42 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { ), const SizedBox(height: 8), ], + if (auth.istAngemeldet && auth.verbleibend != null) ...[ + Row( + children: [ + const Icon(Icons.cloud_outlined, size: 18, color: MeloTheme.text3), + const SizedBox(width: 8), + Expanded( + child: Text( + 'Noch ${auth.verbleibend} von 100 heute', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + ], + ), + const SizedBox(height: 8), + ], + if (istGastModus) ...[ + Row( + children: [ + const Icon(Icons.person_outline, size: 18, color: MeloTheme.text3), + const SizedBox(width: 8), + Expanded( + child: Text( + gast.verbleibend == null + ? 'Als Gast unterwegs (5 Downloads/Tag)' + : 'Als Gast unterwegs — noch ${gast.verbleibend} von 5 heute', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + TextButton( + onPressed: gast.verwerfen, + child: const Text('Anmelden'), + ), + ], + ), + const SizedBox(height: 8), + ], TextField( controller: _url, enabled: !dienst.laeuft, @@ -799,14 +879,15 @@ class _YouTubeBereichState extends State<_YouTubeBereich> { ), const SizedBox(height: 12), _KategorieFeld(controller: _kategorie, aktiv: !dienst.laeuft), - SwitchListTile( - dense: true, - contentPadding: EdgeInsets.zero, - title: const Text('YouTube-Cookies des Servers verwenden'), - subtitle: const Text('Nötig für altersbeschränkte Videos'), - value: _cookies, - onChanged: dienst.laeuft ? null : _setzeCookies, - ), + if (!istGastModus) + SwitchListTile( + dense: true, + contentPadding: EdgeInsets.zero, + title: const Text('YouTube-Cookies des Servers verwenden'), + subtitle: const Text('Nötig für altersbeschränkte Videos'), + value: _cookies, + onChanged: dienst.laeuft ? null : _setzeCookies, + ), if (_orte.length > 1) ...[ const SizedBox(height: 4), DropdownButtonFormField( diff --git a/lib/downloads/youtube_search_screen.dart b/lib/downloads/youtube_search_screen.dart index 6cd35df..f8638a5 100644 --- a/lib/downloads/youtube_search_screen.dart +++ b/lib/downloads/youtube_search_screen.dart @@ -7,6 +7,7 @@ import '../library/database.dart'; import '../library/library_service.dart'; import '../services/baka_auth.dart'; import '../services/download_service.dart'; +import '../services/gast_zugang.dart'; import '../services/media_store.dart'; import '../services/yt_download_service.dart'; import '../services/yt_search_service.dart'; @@ -34,6 +35,12 @@ class _YoutubeSearchScreenState extends State { /// Hinweis auf die manuelle Anmeldung (siehe Download-Tab) sichtbar. bool _autoLoginFehlgeschlagen = false; + /// Fehlertext, falls das Holen des Gast-Tokens scheitert. + String? _gastFehler; + + /// Verhindert Mehrfach-Anfragen bei schnellem Doppel-Antippen. + bool _gastLaeuft = false; + @override void initState() { super.initState(); @@ -51,6 +58,21 @@ class _YoutubeSearchScreenState extends State { }); } + Future _alsGastFortfahren() async { + if (_gastLaeuft) return; + final gast = context.read(); + setState(() { + _gastFehler = null; + _gastLaeuft = true; + }); + final fehler = await gast.holeToken(); + if (!mounted) return; + setState(() { + _gastLaeuft = false; + if (fehler != null) _gastFehler = fehler; + }); + } + @override void dispose() { _query.dispose(); @@ -67,9 +89,12 @@ class _YoutubeSearchScreenState extends State { @override Widget build(BuildContext context) { final auth = context.watch(); + final gast = context.watch(); final suche = context.watch(); - final zugriffOk = - auth.istAngemeldet || (_serverUser && !_autoLoginFehlgeschlagen); + final istGastModus = !_serverUser && !auth.istAngemeldet && gast.hatToken; + final zugriffOk = auth.istAngemeldet || + (_serverUser && !_autoLoginFehlgeschlagen) || + istGastModus; return SafeArea( child: Column( @@ -97,13 +122,77 @@ class _YoutubeSearchScreenState extends State { ], ), ), - if (!zugriffOk) - const Padding( - padding: EdgeInsets.symmetric(horizontal: 16, vertical: 4), + if (!zugriffOk) ...[ + Padding( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4), child: Text( - 'Die Suche läuft über den Baka-Server. Dafür brauchst du ' - 'deine Baka-Anmeldung (siehe Download-Tab).', - style: TextStyle(color: MeloTheme.text2, fontSize: 13), + _serverUser + ? 'Die Suche läuft über den Baka-Server. Dafür brauchst ' + 'du deine Baka-Anmeldung (siehe Download-Tab).' + : 'Die Suche läuft über den Baka-Server. Melde dich mit ' + 'deinem Baka-Konto an (siehe Download-Tab) oder ' + 'nutze sie eingeschränkt als Gast.', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + if (!_serverUser) ...[ + Padding( + padding: const EdgeInsets.symmetric(horizontal: 16), + child: SizedBox( + width: double.infinity, + height: MeloTheme.minTouchTarget + 4, + child: OutlinedButton.icon( + icon: const Icon(Icons.person_outline), + label: const Text('Als Gast fortfahren (5 Downloads/Tag)', + style: TextStyle(fontSize: 16)), + onPressed: _gastLaeuft ? null : _alsGastFortfahren, + ), + ), + ), + if (_gastFehler != null) + Padding( + padding: + const EdgeInsets.symmetric(horizontal: 16, vertical: 4), + child: Text(_gastFehler!, + style: + const TextStyle(color: MeloTheme.red, fontSize: 13)), + ), + ], + ], + if (auth.istAngemeldet && auth.verbleibend != null) + Padding( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4), + child: Row( + children: [ + const Icon(Icons.cloud_outlined, size: 18, color: MeloTheme.text3), + const SizedBox(width: 8), + Expanded( + child: Text( + 'Noch ${auth.verbleibend} von 100 heute', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + ], + ), + ), + if (istGastModus) + Padding( + padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4), + child: Row( + children: [ + Expanded( + child: Text( + gast.verbleibend == null + ? 'Als Gast unterwegs (5 Downloads/Tag)' + : 'Als Gast unterwegs — noch ${gast.verbleibend} von 5 heute', + style: const TextStyle(color: MeloTheme.text2, fontSize: 13), + ), + ), + TextButton( + onPressed: gast.verwerfen, + child: const Text('Anmelden'), + ), + ], ), ), if (suche.laeuft) const LinearProgressIndicator(), diff --git a/lib/main.dart b/lib/main.dart index ad97598..7617d5e 100644 --- a/lib/main.dart +++ b/lib/main.dart @@ -26,6 +26,7 @@ import 'services/baka_auth.dart'; import 'services/logger_service.dart'; import 'services/download_service.dart'; import 'services/geteilte_adresse.dart'; +import 'services/gast_zugang.dart'; import 'services/melo_cloud_service.dart'; import 'services/offline_mode.dart'; import 'services/navidrome_service.dart'; @@ -44,6 +45,7 @@ late final CategoryService _categories; late final AppSettings _settings; late final AudioEffects _effects; late final BakaAuth _bakaAuth; +late final GastZugang _gastZugang; late final YtDownloadService _ytDownload; late final YtSearchService _ytSearch; late final SyncService _sync; @@ -79,8 +81,10 @@ Future main() async { await _effects.init(); _bakaAuth = BakaAuth(); await _bakaAuth.laden(); - _ytDownload = YtDownloadService(auth: _bakaAuth); - _ytSearch = YtSearchService(auth: _bakaAuth); + _gastZugang = GastZugang(); + await _gastZugang.laden(); + _ytDownload = YtDownloadService(auth: _bakaAuth, gast: _gastZugang); + _ytSearch = YtSearchService(auth: _bakaAuth, gast: _gastZugang); _sync = SyncService( db: _db, cloud: MeloCloudService(auth: _bakaAuth), @@ -157,6 +161,7 @@ class _MeloAppState extends State with TickerProviderStateMixin { ChangeNotifierProvider.value(value: _settings), ChangeNotifierProvider.value(value: _effects), ChangeNotifierProvider.value(value: _bakaAuth), + ChangeNotifierProvider.value(value: _gastZugang), ChangeNotifierProvider.value(value: _ytDownload), ChangeNotifierProvider.value(value: _ytSearch), ChangeNotifierProvider.value(value: _sync), diff --git a/lib/services/baka_auth.dart b/lib/services/baka_auth.dart index ca10d08..e2a4e6c 100644 --- a/lib/services/baka_auth.dart +++ b/lib/services/baka_auth.dart @@ -47,6 +47,7 @@ class BakaAuth extends ChangeNotifier { String? _token; String _benutzer = ''; + int? _verbleibend; /// Laufender Login-Versuch aus [autoAnmelden] — solange er offen ist, /// hängt sich ein überlappender Aufruf daran statt einen zweiten @@ -61,6 +62,11 @@ class BakaAuth extends ChangeNotifier { bool get istAngemeldet => _token != null && _token!.isNotEmpty; String get benutzer => _benutzer; + /// Zuletzt vom Server gemeldeter Kontingent-Stand (100/Tag) — nur fürs + /// Anzeigen, die Wahrheit bleibt beim Server. `null` vor dem ersten + /// Download in dieser Session. + int? get verbleibend => _verbleibend; + /// Header für Anfragen an den Proxy. Ohne Anmeldung ohne `Authorization`. Map get authHeader => { if (istAngemeldet) 'Authorization': 'Bearer $_token', @@ -131,9 +137,16 @@ class BakaAuth extends ChangeNotifier { } } + /// Übernimmt den zuletzt vom Server gemeldeten Kontingent-Stand. + void merkeVerbleibend(int n) { + _verbleibend = n; + notifyListeners(); + } + Future abmelden() async { _token = null; _benutzer = ''; + _verbleibend = null; await _speicher.loeschen(_tokenKey); await _speicher.loeschen(_userKey); notifyListeners(); diff --git a/lib/services/gast_zugang.dart b/lib/services/gast_zugang.dart new file mode 100644 index 0000000..5077395 --- /dev/null +++ b/lib/services/gast_zugang.dart @@ -0,0 +1,93 @@ +import 'dart:convert'; + +import 'package:flutter/foundation.dart'; +import 'package:http/http.dart' as http; + +import 'baka_auth.dart' show TokenSpeicher, SicherenSpeicher; +import 'yt_download_service.dart'; + +/// Anonymer Gast-Zugang zum YouTube-Proxy: kein Passwort, aber mit +/// serverseitig durchgesetztem Tages-Limit (der Proxy zählt und meldet den +/// Stand über `guest_remaining` in der yt-dl-Antwort zurück). Ergänzt +/// [BakaAuth]/`baka_auth.dart`, ersetzt es nicht. +class GastZugang extends ChangeNotifier { + GastZugang({http.Client? client, TokenSpeicher? speicher}) + : _client = client ?? http.Client(), + _speicher = speicher ?? const SicherenSpeicher(); + + static const proxyUrl = YtDownloadService.proxyUrl; + static const _tokenKey = 'guest_token'; + + final http.Client _client; + final TokenSpeicher _speicher; + + String? _token; + int? _verbleibend; + + bool get hatToken => _token != null && _token!.isNotEmpty; + + /// Zuletzt vom Server gemeldeter Kontingent-Stand — nur fürs Anzeigen, + /// die Wahrheit bleibt beim Server. `null` vor dem ersten Download. + int? get verbleibend => _verbleibend; + + /// Header für Anfragen an den Proxy. Ohne Token leer. + Map get gastHeader => + {if (hatToken) 'X-Guest-Token': _token!}; + + /// Stellt einen früher geholten Gast-Token wieder her (App-Start). + Future laden() async { + _token = await _speicher.lesen(_tokenKey); + notifyListeners(); + } + + /// Holt einen neuen Gast-Token vom Proxy. Gibt `null` bei Erfolg zurück, + /// sonst den Fehlertext. + Future holeToken() async { + final http.Response antwort; + try { + antwort = await _client + .post(Uri.parse('$proxyUrl/api/guest-token')) + .timeout(const Duration(seconds: 15)); + } catch (e) { + debugPrint('Gast-Token nicht erreichbar: $e'); + return 'Proxy nicht erreichbar'; + } + + if (antwort.statusCode != 200) { + return 'Gast-Zugang fehlgeschlagen (${antwort.statusCode})'; + } + + Map daten; + try { + daten = jsonDecode(antwort.body) as Map; + } catch (_) { + return 'Proxy antwortet unverständlich (${antwort.statusCode})'; + } + + final token = daten['guest_token'] as String?; + if (token == null || token.isEmpty) { + return 'Proxy hat keinen Gast-Token geliefert'; + } + _token = token; + await _speicher.schreiben(_tokenKey, token); + notifyListeners(); + return null; + } + + /// Übernimmt den zuletzt vom Server gemeldeten Kontingent-Stand. + void merkeVerbleibend(int n) { + _verbleibend = n; + notifyListeners(); + } + + /// Verwirft den Gast-Zugang wieder — nötig, damit ein Gast doch noch zum + /// Baka-Konto wechseln kann. Ohne das wäre `_AnmeldeDialog` (der einzige + /// Einstieg in der App für Baka-Login, auch für den Melo-Cloud-Sync) + /// dauerhaft unerreichbar, sobald einmal ein Gast-Token besteht. + Future verwerfen() async { + _token = null; + _verbleibend = null; + await _speicher.loeschen(_tokenKey); + notifyListeners(); + } +} diff --git a/lib/services/yt_download_service.dart b/lib/services/yt_download_service.dart index 006bdf8..cf2e2cb 100644 --- a/lib/services/yt_download_service.dart +++ b/lib/services/yt_download_service.dart @@ -6,6 +6,7 @@ import 'package:flutter/foundation.dart'; import 'package:http/http.dart' as http; import 'baka_auth.dart'; +import 'gast_zugang.dart'; /// Entfernt alles, was in einem Dateinamen Ärger macht. String sichererDateiname(String titel) => @@ -35,12 +36,13 @@ class YtErgebnis { /// Lädt Musik über den Baka-YouTube-Proxy herunter. Der Proxy erledigt die /// eigentliche Arbeit und liefert eine fertige MP3; die App speichert sie nur. class YtDownloadService extends ChangeNotifier { - YtDownloadService({required this.auth, http.Client? client}) + YtDownloadService({required this.auth, this.gast, http.Client? client}) : _client = client ?? http.Client(); static const proxyUrl = 'https://yt.baka-net.de'; final BakaAuth auth; + final GastZugang? gast; final http.Client _client; bool _laeuft = false; @@ -95,7 +97,8 @@ class YtDownloadService extends ChangeNotifier { final abbruch = _abbruch = Completer(); notifyListeners(); - if (!auth.istAngemeldet) { + final gastAktiv = !auth.istAngemeldet && (gast?.hatToken ?? false); + if (!auth.istAngemeldet && !gastAktiv) { _scheitere('Bitte zuerst beim Baka-Konto anmelden'); return null; } @@ -103,6 +106,7 @@ class YtDownloadService extends ChangeNotifier { _scheitere('Das ist keine YouTube-Adresse'); return null; } + final zugangsHeader = gastAktiv ? gast!.gastHeader : auth.authHeader; // ─── 1/2: Proxy fragen — er lädt das Video und wandelt es um ─── _melde('Proxy wird gefragt …'); @@ -113,7 +117,7 @@ class YtDownloadService extends ChangeNotifier { .post( Uri.parse('$proxyUrl/api/yt-dl'), headers: { - ...auth.authHeader, + ...zugangsHeader, 'Content-Type': 'application/json' }, body: jsonEncode({'url': url, 'cookies': cookies}), @@ -137,7 +141,10 @@ class YtDownloadService extends ChangeNotifier { } if (antwort.statusCode == 401) { - _scheitere('Anmeldung abgelaufen — bitte neu anmelden'); + if (gastAktiv) unawaited(gast!.holeToken()); + _scheitere(gastAktiv + ? 'Gast-Zugang abgelaufen — bitte erneut versuchen' + : 'Anmeldung abgelaufen — bitte neu anmelden'); return null; } if (antwort.statusCode != 200) { @@ -149,6 +156,14 @@ class YtDownloadService extends ChangeNotifier { final titel = daten['titel'] as String? ?? 'Unbekannt'; final dauer = (daten['dauer'] as int?) ?? 0; final mp3Url = daten['mp3_url'] as String? ?? '/api/dl/audio.mp3'; + final gastRest = daten['guest_remaining'] as int?; + if (gastAktiv && gastRest != null) { + gast!.merkeVerbleibend(gastRest); + } + final cloudRest = daten['cloud_remaining'] as int?; + if (!gastAktiv && cloudRest != null) { + auth.merkeVerbleibend(cloudRest); + } // ─── 2/2: fertige MP3 abholen und speichern ─── _melde('Lade „$titel“ …'); @@ -161,7 +176,7 @@ class YtDownloadService extends ChangeNotifier { try { final mp3 = await _abbrechbar( _client - .get(Uri.parse('$proxyUrl$mp3Url'), headers: auth.authHeader) + .get(Uri.parse('$proxyUrl$mp3Url'), headers: zugangsHeader) .timeout(const Duration(seconds: 180)), abbruch, ); diff --git a/lib/services/yt_search_service.dart b/lib/services/yt_search_service.dart index 69ee99a..0c08bd9 100644 --- a/lib/services/yt_search_service.dart +++ b/lib/services/yt_search_service.dart @@ -5,6 +5,7 @@ import 'package:flutter/foundation.dart'; import 'package:http/http.dart' as http; import 'baka_auth.dart'; +import 'gast_zugang.dart'; import 'yt_download_service.dart'; /// Ein Treffer der YouTube-Suche über den Baka-Proxy. @@ -44,12 +45,13 @@ String? youtubeVideoId(String url) { /// Durchsucht YouTube über den Baka-Proxy (`/api/search`, yt-dlp-gestützt) — /// dieselbe Anmeldung wie [YtDownloadService]. class YtSearchService extends ChangeNotifier { - YtSearchService({required this.auth, http.Client? client}) + YtSearchService({required this.auth, this.gast, http.Client? client}) : _client = client ?? http.Client(); static const proxyUrl = YtDownloadService.proxyUrl; final BakaAuth auth; + final GastZugang? gast; final http.Client _client; bool _laeuft = false; @@ -64,7 +66,8 @@ class YtSearchService extends ChangeNotifier { final q = query.trim(); if (q.isEmpty) return; - if (!auth.istAngemeldet) { + final gastAktiv = !auth.istAngemeldet && (gast?.hatToken ?? false); + if (!auth.istAngemeldet && !gastAktiv) { _treffer = const []; _fehler = 'Bitte zuerst beim Baka-Konto anmelden'; notifyListeners(); @@ -80,7 +83,7 @@ class YtSearchService extends ChangeNotifier { final http.Response antwort; try { antwort = await _client - .get(uri, headers: auth.authHeader) + .get(uri, headers: gastAktiv ? gast!.gastHeader : auth.authHeader) .timeout(const Duration(seconds: 20)); } on TimeoutException { _scheitere('Die Suche braucht zu lange — bitte später erneut versuchen'); @@ -92,7 +95,10 @@ class YtSearchService extends ChangeNotifier { } if (antwort.statusCode == 401) { - _scheitere('Anmeldung abgelaufen — bitte neu anmelden'); + if (gastAktiv) unawaited(gast!.holeToken()); + _scheitere(gastAktiv + ? 'Gast-Zugang abgelaufen — bitte erneut versuchen' + : 'Anmeldung abgelaufen — bitte neu anmelden'); return; } if (antwort.statusCode != 200) { diff --git a/test/downloads/online_screen_test.dart b/test/downloads/online_screen_test.dart index 607104b..52c2194 100644 --- a/test/downloads/online_screen_test.dart +++ b/test/downloads/online_screen_test.dart @@ -11,6 +11,7 @@ import 'package:melo/library/category_service.dart'; import 'package:melo/library/database.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/yt_download_service.dart'; import 'package:provider/provider.dart'; @@ -29,7 +30,9 @@ class _MemorySpeicher implements TokenSpeicher { Widget _wrap(BakaAuth auth, {required MeloDb db, required CategoryService categories, - NavidromeService? navidrome}) { + NavidromeService? navidrome, + GastZugang? gast}) { + final gastZugang = gast ?? GastZugang(); return MultiProvider( providers: [ Provider.value(value: db), @@ -38,9 +41,11 @@ Widget _wrap(BakaAuth auth, // Aufräum-Timer von drift im Test-Rahmen hängen. ChangeNotifierProvider.value(value: categories), ChangeNotifierProvider.value(value: auth), + ChangeNotifierProvider.value(value: gastZugang), ChangeNotifierProvider( create: (_) => YtDownloadService( auth: auth, + gast: gastZugang, client: MockClient((_) async => http.Response('', 500)), ), ), @@ -301,6 +306,21 @@ void main() { expect(auth.istAngemeldet, isTrue); }); + testWidgets( + 'Angemeldeter Cloud-Account sieht das Kontingent nach einem Download', + (tester) async { + final auth = await _angemeldet(); + + await tester.pumpWidget(_wrap(auth, db: db, categories: categories)); + await tester.pumpAndSettle(); + expect(find.textContaining('von 100 heute'), findsNothing); + + auth.merkeVerbleibend(63); + await tester.pump(); + + expect(find.text('Noch 63 von 100 heute'), findsOneWidget); + }); + testWidgets( 'Server-User meldet sich im Hintergrund mit denselben Zugangsdaten ' 'beim Baka-Konto an', (tester) async { @@ -323,4 +343,91 @@ void main() { expect(gesendeterBenutzer, 'Tinker'); expect(auth.istAngemeldet, isTrue); }); + + testWidgets('Gast sieht zwei Buttons: Anmelden und Als Gast fortfahren', + (tester) async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + + await tester.pumpWidget(_wrap(auth, db: db, categories: categories)); + await tester.pumpAndSettle(); + + expect(find.text('Beim Baka-Konto anmelden'), findsOneWidget); + expect( + find.text('Als Gast fortfahren (5 Downloads/Tag)'), findsOneWidget); + expect(find.text('YouTube-Adresse'), findsNothing); + }); + + testWidgets( + 'Als Gast fortfahren holt einen Token und schaltet das Adressfeld frei', + (tester) async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final gast = GastZugang( + client: MockClient((_) async => + http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: _MemorySpeicher(), + ); + + await tester.pumpWidget( + _wrap(auth, db: db, categories: categories, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + + expect(find.text('YouTube-Adresse'), findsOneWidget); + expect(find.text('Als Gast unterwegs (5 Downloads/Tag)'), findsOneWidget); + expect(find.text('YouTube-Cookies des Servers verwenden'), findsNothing); + }); + + testWidgets('Fehler beim Gast-Token wird angezeigt', (tester) async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + + await tester.pumpWidget( + _wrap(auth, db: db, categories: categories, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + + expect(find.text('Gast-Zugang fehlgeschlagen (500)'), findsOneWidget); + expect(find.text('YouTube-Adresse'), findsNothing); + }); + + testWidgets( + 'Anmelden im Gast-Modus verwirft den Gast-Token und zeigt wieder die ' + 'Wahl', (tester) async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final gast = GastZugang( + client: MockClient((_) async => + http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: _MemorySpeicher(), + ); + + await tester.pumpWidget( + _wrap(auth, db: db, categories: categories, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + expect(find.text('YouTube-Adresse'), findsOneWidget); + + await tester.tap(find.text('Anmelden')); + await tester.pumpAndSettle(); + + expect(find.text('Beim Baka-Konto anmelden'), findsOneWidget); + expect(find.text('YouTube-Adresse'), findsNothing); + expect(gast.hatToken, isFalse); + }); } diff --git a/test/downloads/youtube_search_screen_test.dart b/test/downloads/youtube_search_screen_test.dart index 1123b9d..3b93f26 100644 --- a/test/downloads/youtube_search_screen_test.dart +++ b/test/downloads/youtube_search_screen_test.dart @@ -11,6 +11,7 @@ import 'package:melo/library/database.dart'; import 'package:melo/library/library_service.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/yt_download_service.dart'; import 'package:melo/services/yt_search_service.dart'; @@ -43,12 +44,14 @@ Widget _wrap({ required YtSearchService search, required YtDownloadService download, NavidromeService? navidrome, + GastZugang? gast, }) { return MultiProvider( providers: [ Provider.value(value: db), ChangeNotifierProvider.value(value: LibraryService(db)), ChangeNotifierProvider.value(value: auth), + ChangeNotifierProvider.value(value: gast ?? GastZugang()), ChangeNotifierProvider.value(value: search), ChangeNotifierProvider.value(value: download), // Nur für die Server-User-Prüfung gebraucht (siehe @@ -89,7 +92,7 @@ void main() { db: db, auth: auth, search: search, download: download)); await tester.pumpAndSettle(); - expect(find.textContaining('Baka-Anmeldung'), findsOneWidget); + expect(find.textContaining('Baka-Server'), findsOneWidget); expect(find.text('Nach Musikvideos suchen'), findsOneWidget); await db.close(); @@ -173,6 +176,26 @@ void main() { await db.close(); }); + testWidgets('Angemeldeter Cloud-Account sieht das Kontingent nach Download', + (tester) async { + final db = MeloDb(NativeDatabase.memory()); + final auth = await _angemeldeteAuth(); + final search = YtSearchService(auth: auth); + final download = YtDownloadService(auth: auth); + + await tester.pumpWidget(_wrap( + db: db, auth: auth, search: search, download: download)); + await tester.pumpAndSettle(); + expect(find.textContaining('von 100 heute'), findsNothing); + + auth.merkeVerbleibend(98); + await tester.pump(); + + expect(find.text('Noch 98 von 100 heute'), findsOneWidget); + + await db.close(); + }); + // Kein Widget-Test für den Download-Knopf selbst: YtDownloadService. // herunterladen() kombiniert Future.any mit .timeout() — dessen Timer // bleibt unter Flutters fake_async-Testbindung immer als "pending" stehen @@ -182,4 +205,86 @@ void main() { // _YouTubeBereich (downloads_screen.dart) keinen eigenen Widget-Test — // die Download-Logik selbst ist über yt_download_test.dart ausführlich // abgedeckt. + + testWidgets('Gast sieht den Button "Als Gast fortfahren"', (tester) async { + final db = MeloDb(NativeDatabase.memory()); + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + final search = YtSearchService(auth: auth, gast: gast); + final download = YtDownloadService(auth: auth, gast: gast); + + await tester.pumpWidget(_wrap( + db: db, auth: auth, search: search, download: download, gast: gast)); + await tester.pumpAndSettle(); + + expect( + find.text('Als Gast fortfahren (5 Downloads/Tag)'), findsOneWidget); + + await db.close(); + }); + + testWidgets( + 'Als Gast fortfahren blendet den Baka-Hinweis aus und zeigt den Zähler', + (tester) async { + final db = MeloDb(NativeDatabase.memory()); + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final gast = GastZugang( + client: MockClient((_) async => + http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: _MemorySpeicher(), + ); + final search = YtSearchService(auth: auth, gast: gast); + final download = YtDownloadService(auth: auth, gast: gast); + + await tester.pumpWidget(_wrap( + db: db, auth: auth, search: search, download: download, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + + expect(find.textContaining('Baka-Anmeldung'), findsNothing); + expect(find.text('Als Gast unterwegs (5 Downloads/Tag)'), findsOneWidget); + + await db.close(); + }); + + testWidgets( + 'Anmelden im Gast-Modus verwirft den Gast-Token und zeigt wieder den ' + 'Hinweis', (tester) async { + final db = MeloDb(NativeDatabase.memory()); + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + final search = YtSearchService(auth: auth); + final download = YtDownloadService(auth: auth); + final gast = GastZugang( + client: MockClient((_) async => + http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: _MemorySpeicher(), + ); + + await tester.pumpWidget(_wrap( + db: db, auth: auth, search: search, download: download, gast: gast)); + await tester.pumpAndSettle(); + + await tester.tap(find.text('Als Gast fortfahren (5 Downloads/Tag)')); + await tester.pumpAndSettle(); + expect(find.text('Als Gast unterwegs (5 Downloads/Tag)'), findsOneWidget); + + await tester.tap(find.text('Anmelden')); + await tester.pumpAndSettle(); + + expect(find.textContaining('Baka-Server'), findsOneWidget); + expect(gast.hatToken, isFalse); + + await db.close(); + }); } diff --git a/test/hauptmenue_test.dart b/test/hauptmenue_test.dart index 79590ab..1f86c8a 100644 --- a/test/hauptmenue_test.dart +++ b/test/hauptmenue_test.dart @@ -10,6 +10,7 @@ import 'package:melo/player/audio_handler.dart'; import 'package:melo/player/player_expansion_controller.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/melo_cloud_service.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/offline_mode.dart'; @@ -52,6 +53,7 @@ void main() { late YtSearchService ytSearch; late DownloadService downloads; late SyncService sync; + late GastZugang gast; MeloAudioHandler? handler; PlayerExpansionController? expansion; @@ -64,8 +66,9 @@ void main() { auth = BakaAuth(speicher: _MemorySpeicher()); einstellungen = AppSettings(); offline = OfflineMode(); - ytDownload = YtDownloadService(auth: auth); - ytSearch = YtSearchService(auth: auth); + gast = GastZugang(); + ytDownload = YtDownloadService(auth: auth, gast: gast); + ytSearch = YtSearchService(auth: auth, gast: gast); downloads = DownloadService(db: db, navidrome: NavidromeService()); sync = SyncService(db: db, cloud: MeloCloudService(auth: auth)); }); @@ -101,6 +104,7 @@ void main() { ChangeNotifierProvider.value(value: einstellungen), ChangeNotifierProvider.value(value: offline), ChangeNotifierProvider.value(value: auth), + ChangeNotifierProvider.value(value: gast), ChangeNotifierProvider.value(value: ytDownload), ChangeNotifierProvider.value(value: ytSearch), ChangeNotifierProvider.value(value: downloads), diff --git a/test/home_shell_test.dart b/test/home_shell_test.dart index 6631599..215899c 100644 --- a/test/home_shell_test.dart +++ b/test/home_shell_test.dart @@ -10,6 +10,7 @@ import 'package:melo/player/audio_handler.dart'; import 'package:melo/player/player_expansion_controller.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/melo_cloud_service.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/offline_mode.dart'; @@ -52,6 +53,7 @@ void main() { ChangeNotifierProvider(create: (_) => AppSettings()), ChangeNotifierProvider(create: (_) => OfflineMode()), ChangeNotifierProvider(create: (_) => auth), + ChangeNotifierProvider(create: (_) => GastZugang()), ChangeNotifierProvider( create: (_) => YtDownloadService(auth: auth)), ChangeNotifierProvider( @@ -97,6 +99,7 @@ void main() { ChangeNotifierProvider(create: (_) => AppSettings()), ChangeNotifierProvider(create: (_) => OfflineMode()), ChangeNotifierProvider(create: (_) => auth), + ChangeNotifierProvider(create: (_) => GastZugang()), ChangeNotifierProvider( create: (_) => YtDownloadService(auth: auth)), ChangeNotifierProvider( diff --git a/test/player/home_shell_real_expansion_test.dart b/test/player/home_shell_real_expansion_test.dart index bd8e94b..2602bef 100644 --- a/test/player/home_shell_real_expansion_test.dart +++ b/test/player/home_shell_real_expansion_test.dart @@ -11,6 +11,7 @@ import 'package:melo/player/mini_player.dart'; import 'package:melo/player/player_expansion_controller.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/melo_cloud_service.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/offline_mode.dart'; @@ -56,6 +57,7 @@ void main() { ChangeNotifierProvider(create: (_) => AppSettings()), ChangeNotifierProvider(create: (_) => OfflineMode()), ChangeNotifierProvider(create: (_) => auth), + ChangeNotifierProvider(create: (_) => GastZugang()), ChangeNotifierProvider( create: (_) => YtDownloadService(auth: auth)), ChangeNotifierProvider( @@ -125,6 +127,7 @@ void main() { ChangeNotifierProvider(create: (_) => AppSettings()), ChangeNotifierProvider(create: (_) => OfflineMode()), ChangeNotifierProvider(create: (_) => auth), + ChangeNotifierProvider(create: (_) => GastZugang()), ChangeNotifierProvider( create: (_) => YtDownloadService(auth: auth)), ChangeNotifierProvider( diff --git a/test/player/provider_scope_navigator_push_test.dart b/test/player/provider_scope_navigator_push_test.dart index c26db85..974b832 100644 --- a/test/player/provider_scope_navigator_push_test.dart +++ b/test/player/provider_scope_navigator_push_test.dart @@ -14,6 +14,7 @@ import 'package:melo/player/player_expansion_controller.dart'; import 'package:melo/playlists/playlist_detail_screen.dart'; import 'package:melo/services/baka_auth.dart'; import 'package:melo/services/download_service.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/melo_cloud_service.dart'; import 'package:melo/services/navidrome_service.dart'; import 'package:melo/services/offline_mode.dart'; @@ -98,6 +99,7 @@ void main() { ChangeNotifierProvider(create: (_) => AppSettings()), ChangeNotifierProvider(create: (_) => OfflineMode()), ChangeNotifierProvider(create: (_) => auth), + ChangeNotifierProvider(create: (_) => GastZugang()), ChangeNotifierProvider( create: (_) => YtDownloadService(auth: auth)), ChangeNotifierProvider( diff --git a/test/services/baka_auth_test.dart b/test/services/baka_auth_test.dart index 2e0b74f..21dbe3a 100644 --- a/test/services/baka_auth_test.dart +++ b/test/services/baka_auth_test.dart @@ -167,6 +167,34 @@ void main() { expect(auth.istAngemeldet, isFalse); }); + test('merkeVerbleibend übernimmt den Kontingent-Stand und meldet Listener', + () async { + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + var benachrichtigt = 0; + auth.addListener(() => benachrichtigt++); + + auth.merkeVerbleibend(37); + + expect(auth.verbleibend, 37); + expect(benachrichtigt, 1); + }); + + test('Abmelden setzt auch den Kontingent-Stand zurück', () async { + final speicher = _MemorySpeicher(); + final auth = BakaAuth( + client: MockClient( + (_) async => http.Response(jsonEncode({'token': 'jwt-abc'}), 200)), + speicher: speicher); + await auth.anmelden('Baka', 'geheim'); + auth.merkeVerbleibend(42); + + await auth.abmelden(); + + expect(auth.verbleibend, isNull); + }); + test('Abmelden löscht Token und Benutzer aus dem Speicher', () async { final speicher = _MemorySpeicher(); final auth = BakaAuth( diff --git a/test/services/gast_zugang_test.dart b/test/services/gast_zugang_test.dart new file mode 100644 index 0000000..cb54fa5 --- /dev/null +++ b/test/services/gast_zugang_test.dart @@ -0,0 +1,120 @@ +import 'dart:convert'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:http/http.dart' as http; +import 'package:http/testing.dart'; +import 'package:melo/services/baka_auth.dart'; +import 'package:melo/services/gast_zugang.dart'; + +class _MemorySpeicher implements TokenSpeicher { + final Map werte = {}; + @override + Future lesen(String key) async => werte[key]; + @override + Future schreiben(String key, String wert) async => werte[key] = wert; + @override + Future loeschen(String key) async => werte.remove(key); +} + +void main() { + test('Ohne Token ist gastHeader leer', () { + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + + expect(gast.hatToken, isFalse); + expect(gast.gastHeader, isEmpty); + }); + + test('holeToken() speichert den Token bei Erfolg', () async { + final speicher = _MemorySpeicher(); + final gast = GastZugang( + client: MockClient( + (_) async => http.Response(jsonEncode({'guest_token': 'g-1'}), 200)), + speicher: speicher, + ); + + final fehler = await gast.holeToken(); + + expect(fehler, isNull); + expect(gast.hatToken, isTrue); + expect(gast.gastHeader, {'X-Guest-Token': 'g-1'}); + expect(speicher.werte['guest_token'], 'g-1'); + }); + + test('holeToken() meldet einen Fehler bei einer toten Verbindung', + () async { + final gast = GastZugang( + client: MockClient((_) async => throw Exception('down')), + speicher: _MemorySpeicher(), + ); + + final fehler = await gast.holeToken(); + + expect(fehler, 'Proxy nicht erreichbar'); + expect(gast.hatToken, isFalse); + }); + + test('holeToken() meldet einen Fehler bei einem Server-Fehlerstatus', + () async { + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + + final fehler = await gast.holeToken(); + + expect(fehler, 'Gast-Zugang fehlgeschlagen (500)'); + expect(gast.hatToken, isFalse); + }); + + test('holeToken() meldet einen Fehler bei unlesbarer Antwort', () async { + final gast = GastZugang( + client: MockClient((_) async => http.Response('nicht json', 200)), + speicher: _MemorySpeicher(), + ); + + final fehler = await gast.holeToken(); + + expect(fehler, 'Proxy antwortet unverständlich (200)'); + expect(gast.hatToken, isFalse); + }); + + test('holeToken() meldet einen Fehler ohne guest_token-Feld', () async { + final gast = GastZugang( + client: MockClient((_) async => http.Response(jsonEncode({}), 200)), + speicher: _MemorySpeicher(), + ); + + final fehler = await gast.holeToken(); + + expect(fehler, 'Proxy hat keinen Gast-Token geliefert'); + expect(gast.hatToken, isFalse); + }); + + test('laden() stellt einen gespeicherten Gast-Token wieder her', () async { + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'g-alt'; + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: speicher, + ); + + await gast.laden(); + + expect(gast.hatToken, isTrue); + expect(gast.gastHeader, {'X-Guest-Token': 'g-alt'}); + }); + + test('merkeVerbleibend übernimmt den zuletzt gemeldeten Stand', () { + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher(), + ); + + gast.merkeVerbleibend(3); + + expect(gast.verbleibend, 3); + }); +} diff --git a/test/services/yt_download_test.dart b/test/services/yt_download_test.dart index b915abe..97c4798 100644 --- a/test/services/yt_download_test.dart +++ b/test/services/yt_download_test.dart @@ -6,6 +6,7 @@ import 'package:flutter_test/flutter_test.dart'; import 'package:http/http.dart' as http; import 'package:http/testing.dart'; import 'package:melo/services/baka_auth.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/yt_download_service.dart'; class _MemorySpeicher implements TokenSpeicher { @@ -284,4 +285,171 @@ void main() { expect((jsonDecode(auftrag!) as Map)['cookies'], isFalse); }); + + group('Gast-Zugang', () { + test('Mit Gast-Token statt Anmeldung wird der Proxy trotzdem gefragt', + () async { + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'gast-xyz'; + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: speicher, + ); + await gast.laden(); + + final dienst = YtDownloadService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + gast: gast, + client: MockClient((req) async { + if (req.url.path == '/api/yt-dl') { + expect(req.headers['X-Guest-Token'], 'gast-xyz'); + expect(req.headers.containsKey('Authorization'), isFalse); + return http.Response( + jsonEncode({ + 'titel': 'Gast-Lied', + 'dauer': 30, + 'mp3_url': '/api/dl/g.mp3', + 'guest_remaining': 4, + }), + 200); + } + return http.Response.bytes([1], 200); + }), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + + expect(ergebnis, isNotNull); + expect(gast.verbleibend, 4); + }); + + test('Ohne Anmeldung UND ohne Gast-Token wird gar nicht erst gefragt', + () async { + var aufrufe = 0; + final dienst = YtDownloadService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + client: MockClient((_) async { + aufrufe++; + return http.Response('', 200); + }), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + + expect(ergebnis, isNull); + expect(dienst.fehler, 'Bitte zuerst beim Baka-Konto anmelden'); + expect(aufrufe, 0); + }); + + test('401 bei Gast-Zugang holt automatisch einen neuen Gast-Token', + () async { + var tokenAufrufe = 0; + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'alter-token'; + final gast = GastZugang( + client: MockClient((_) async { + tokenAufrufe++; + return http.Response( + jsonEncode({'guest_token': 'neuer-token'}), 200); + }), + speicher: speicher, + ); + await gast.laden(); + + final dienst = YtDownloadService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + gast: gast, + client: MockClient((_) async => http.Response('Unauthorized', 401)), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + // Das Token-Nachholen läuft unawaited im Hintergrund. + await Future.delayed(Duration.zero); + + expect(ergebnis, isNull); + expect(dienst.fehler, 'Gast-Zugang abgelaufen — bitte erneut versuchen'); + expect(tokenAufrufe, 1); + }); + }); + + group('Cloud-Kontingent', () { + test('cloud_remaining aus der Erfolgsantwort landet in auth.verbleibend', + () async { + final auth = await _angemeldeteAuth(); + final dienst = YtDownloadService( + auth: auth, + client: MockClient((req) async { + if (req.url.path == '/api/yt-dl') { + return http.Response( + jsonEncode({ + 'titel': 'Cloud-Lied', + 'dauer': 30, + 'mp3_url': '/api/dl/c.mp3', + 'cloud_remaining': 99, + }), + 200); + } + return http.Response.bytes([1], 200); + }), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + + expect(ergebnis, isNotNull); + expect(auth.verbleibend, 99); + }); + + test( + 'Bei Gast-Zugriff wird cloud_remaining nicht gelesen, selbst wenn es ' + 'im Body steht', () async { + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'gast-xyz'; + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: speicher, + ); + await gast.laden(); + final auth = BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()); + + final dienst = YtDownloadService( + auth: auth, + gast: gast, + client: MockClient((req) async { + if (req.url.path == '/api/yt-dl') { + return http.Response( + jsonEncode({ + 'titel': 'Gast-Lied', + 'dauer': 30, + 'mp3_url': '/api/dl/g.mp3', + 'guest_remaining': 4, + // Sollte serverseitig nie gleichzeitig vorkommen, aber + // falls doch: darf nicht in auth.verbleibend landen. + 'cloud_remaining': 77, + }), + 200); + } + return http.Response.bytes([1], 200); + }), + ); + + final ergebnis = await dienst.herunterladen('https://youtu.be/abc', + zielOrdner: ziel.path); + + expect(ergebnis, isNotNull); + expect(gast.verbleibend, 4); + expect(auth.verbleibend, isNull); + }); + }); } diff --git a/test/services/yt_search_service_test.dart b/test/services/yt_search_service_test.dart index 181fd24..f033673 100644 --- a/test/services/yt_search_service_test.dart +++ b/test/services/yt_search_service_test.dart @@ -5,6 +5,7 @@ import 'package:flutter_test/flutter_test.dart'; import 'package:http/http.dart' as http; import 'package:http/testing.dart'; import 'package:melo/services/baka_auth.dart'; +import 'package:melo/services/gast_zugang.dart'; import 'package:melo/services/yt_search_service.dart'; class _MemorySpeicher implements TokenSpeicher { @@ -200,5 +201,61 @@ void main() { await dienst.suchen('zweite suche'); expect(dienst.treffer.single.title, 'Zweites'); }); + + test('Mit Gast-Token statt Anmeldung wird trotzdem gesucht', () async { + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'gast-xyz'; + final gast = GastZugang( + client: MockClient((_) async => http.Response('', 500)), + speicher: speicher, + ); + await gast.laden(); + + final dienst = YtSearchService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + gast: gast, + client: MockClient((req) async { + expect(req.headers['X-Guest-Token'], 'gast-xyz'); + expect(req.headers.containsKey('Authorization'), isFalse); + return http.Response('[]', 200); + }), + ); + + await dienst.suchen('roses'); + + expect(dienst.fehler, isNull); + }); + + test('401 bei Gast-Zugang holt automatisch einen neuen Gast-Token', + () async { + var tokenAufrufe = 0; + final speicher = _MemorySpeicher(); + speicher.werte['guest_token'] = 'alter-token'; + final gast = GastZugang( + client: MockClient((_) async { + tokenAufrufe++; + return http.Response( + jsonEncode({'guest_token': 'neuer-token'}), 200); + }), + speicher: speicher, + ); + await gast.laden(); + + final dienst = YtSearchService( + auth: BakaAuth( + client: MockClient((_) async => http.Response('', 500)), + speicher: _MemorySpeicher()), + gast: gast, + client: MockClient((_) async => http.Response('Unauthorized', 401)), + ); + + await dienst.suchen('roses'); + await Future.delayed(Duration.zero); + + expect(dienst.fehler, 'Gast-Zugang abgelaufen — bitte erneut versuchen'); + expect(tokenAufrufe, 1); + }); }); }