dustin/Melo
1
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

Playlisten-Endpunkte fuer die einseitige Sicherung (ohne DELETE)

Browse Source
This commit is contained in:
Hermes (Server)
2026-08-27 13:37:37 +02:00
parent 3cd88565ec
commit 0519c68b26
2 changed files with 280 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/services/melo_cloud_service.dart
+130
View File
@@ -42,6 +42,14 @@ class CloudSong {
);
}
/// Eine Playlist, wie sie der Server kennt. Mehr als Name und ID braucht die
/// einseitige Sicherung nicht.
class CloudPlaylist {
const CloudPlaylist({required this.id, required this.name});
final String id;
final String name;
}
/// Ein Wiedergabe-Ereignis, das zum Server gemeldet wird.
class CloudVerlauf {
const CloudVerlauf({
@@ -293,6 +301,128 @@ class MeloCloudService {
_pruefeStatus(antwort);
}
/// Der Körper einer Playlisten-Antwort, oder `CloudException`.
///
/// Der Server meldet Fehler im 200er-Körper unter `error`. Ein bloßes
/// `{"status":"not_found"}` **ohne** `error` (so antworten
/// `handle_playlist_remove_song` und `handle_playlist_update_positions`)
/// geht hier bewusst durch: die Sicherung ist einseitig und
/// fire-and-forget, sie verwirft jeden Fehler ohnehin.
Map<String, dynamic> _json(http.Response antwort) {
final daten = jsonDecode(antwort.body) as Map<String, dynamic>;
final fehler = daten['error'] as String?;
if (fehler != null) throw CloudException(fehler);
return daten;
}
/// Legt eine Playlist am Server an und gibt deren ID zurück.
///
/// Die Identität stammt **immer** von hier: `user_playlists.id` ist
/// AUTOINCREMENT und damit stabil. Eine Zuordnung über den Namen gibt es
/// nicht — sie zerbräche beim ersten Umbenennen.
Future<String> legePlaylistAn(String name) async {
_pruefeAnmeldung();
final antwort = await _client
.post(
Uri.parse('$basisUrl/playlists'),
headers: {..._kopf, 'Content-Type': 'application/json'},
body: jsonEncode({'name': name}),
)
.timeout(const Duration(seconds: 30));
_pruefeStatus(antwort);
// handle_playlist_create antwortet {"status":"ok","playlist":{"id":…}} —
// die ID liegt eine Ebene tiefer, nicht auf oberster Ebene.
final playlist = _json(antwort)['playlist'];
if (playlist is! Map<String, dynamic>) {
throw CloudException('Antwort ohne Playlist');
}
return '${playlist['id']}';
}
Future<void> fuegePlaylistSongsHinzu(
String playlistCloudId, List<String> songCloudIds) async {
if (songCloudIds.isEmpty) return;
_pruefeAnmeldung();
final antwort = await _client
.post(
Uri.parse('$basisUrl/playlists/$playlistCloudId/songs'),
headers: {..._kopf, 'Content-Type': 'application/json'},
body: jsonEncode({'song_ids': songCloudIds}),
)
.timeout(const Duration(seconds: 30));
_pruefeStatus(antwort);
_json(antwort);
}
Future<void> entfernePlaylistSong(
String playlistCloudId, String songCloudId) async {
_pruefeAnmeldung();
final antwort = await _client
.delete(
Uri.parse('$basisUrl/playlists/$playlistCloudId/songs/$songCloudId'),
headers: _kopf,
)
.timeout(const Duration(seconds: 30));
_pruefeStatus(antwort);
_json(antwort);
}
/// Schreibt die Reihenfolge einer Playlist am Server fest.
///
/// Der Körper heißt `positions` und trägt Paare aus `id` und `position`:
/// Der Router liest `d.get('positions',[])`, der Handler greift je Eintrag
/// auf beide Schlüssel zu. Eine blanke ID-Liste unter `song_ids` käme als
/// leere Liste an — der Server antwortete stumm `{"status":"ok"}` und
/// änderte nichts.
Future<void> setzePlaylistReihenfolge(
String playlistCloudId, List<String> songCloudIds) async {
_pruefeAnmeldung();
final antwort = await _client
.put(
Uri.parse('$basisUrl/playlists/$playlistCloudId/positions'),
headers: {..._kopf, 'Content-Type': 'application/json'},
body: jsonEncode({
'positions': [
for (var i = 0; i < songCloudIds.length; i++)
{'id': songCloudIds[i], 'position': i},
],
}),
)
.timeout(const Duration(seconds: 30));
_pruefeStatus(antwort);
_json(antwort);
}
Future<List<CloudPlaylist>> playlisten() async {
_pruefeAnmeldung();
final antwort = await _client
.get(Uri.parse('$basisUrl/playlists'), headers: _kopf)
.timeout(const Duration(seconds: 30));
_pruefeStatus(antwort);
final liste = _json(antwort)['playlists'];
if (liste is! List) throw CloudException('Antwort ohne Playlisten');
return [
for (final j in liste)
CloudPlaylist(
id: '${(j as Map<String, dynamic>)['id']}',
name: j['name'] as String? ?? 'Ohne Namen',
),
];
}
Future<List<String>> playlistSongs(String playlistCloudId) async {
_pruefeAnmeldung();
final antwort = await _client
.get(Uri.parse('$basisUrl/playlists/$playlistCloudId'), headers: _kopf)
.timeout(const Duration(seconds: 30));
_pruefeStatus(antwort);
final liste = _json(antwort)['songs'];
if (liste is! List) throw CloudException('Antwort ohne Titel');
return [
for (final j in liste) '${(j as Map<String, dynamic>)['id']}',
];
}
/// Meldet Wiedergaben. Der Server nimmt höchstens 100 je Aufruf an und
/// verwirft Doppelmeldungen desselben Titels innerhalb einer Stunde.
Future<void> meldeVerlauf(List<CloudVerlauf> eintraege) async {
test/services/melo_cloud_playlists_test.dart
+150
View File
@@ -0,0 +1,150 @@
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/melo_cloud_service.dart';
class _MemorySpeicher implements TokenSpeicher {
_MemorySpeicher(this.werte);
final Map<String, String> werte;
@override
Future<String?> lesen(String key) async => werte[key];
@override
Future<void> schreiben(String key, String wert) async => werte[key] = wert;
@override
Future<void> loeschen(String key) async => werte.remove(key);
}
Future<MeloCloudService> baue(
Future<http.Response> Function(http.Request) antwort) async {
final auth = BakaAuth(
speicher: _MemorySpeicher({'baka_token': 'tok', 'baka_user': 'Baka'}),
);
await auth.laden();
return MeloCloudService(auth: auth, client: MockClient(antwort));
}
void main() {
test('legePlaylistAn liefert die Server-ID', () async {
final dienst = await baue((anfrage) async {
expect(anfrage.method, 'POST');
expect(anfrage.url.path, endsWith('/playlists'));
expect(jsonDecode(anfrage.body), {'name': 'Road Trip'});
// handle_playlist_create verpackt die ID unter „playlist" — genau so
// antwortet der echte Server, und genau daran ist der Vertrag geknüpft.
return http.Response(
jsonEncode({
'status': 'ok',
'playlist': {'id': 7, 'name': 'Road Trip', 'song_count': 0}
}),
200,
);
});
expect(await dienst.legePlaylistAn('Road Trip'), '7');
});
test('eine Antwort ohne playlist-Block ist ein Fehler', () async {
// Die ID auf oberster Ebene zu suchen wäre der naheliegende Fehler; er
// fiele am echten Server als „null" auf und sonst nirgends.
final dienst = await baue(
(_) async => http.Response(jsonEncode({'status': 'ok'}), 200));
expect(() => dienst.legePlaylistAn('Road Trip'),
throwsA(isA<CloudException>()));
});
test('ein Fehler im 200er-Körper wird geworfen', () async {
final dienst = await baue((_) async =>
http.Response(jsonEncode({'error': 'kein Name'}), 200));
expect(() => dienst.legePlaylistAn(''),
throwsA(isA<CloudException>()));
});
test('fuegePlaylistSongsHinzu meldet die Song-IDs', () async {
Map<String, dynamic>? gesendet;
final dienst = await baue((anfrage) async {
expect(anfrage.url.path, endsWith('/playlists/7/songs'));
gesendet = jsonDecode(anfrage.body) as Map<String, dynamic>;
return http.Response(jsonEncode({'status': 'ok'}), 200);
});
await dienst.fuegePlaylistSongsHinzu('7', ['c1', 'c2']);
expect(gesendet, {
'song_ids': ['c1', 'c2']
});
});
test('entfernePlaylistSong benutzt DELETE auf dem Song-Pfad', () async {
String? pfad;
String? methode;
final dienst = await baue((anfrage) async {
pfad = anfrage.url.path;
methode = anfrage.method;
return http.Response(jsonEncode({'status': 'ok'}), 200);
});
await dienst.entfernePlaylistSong('7', 'c1');
expect(methode, 'DELETE');
expect(pfad, endsWith('/playlists/7/songs/c1'));
});
test('setzePlaylistReihenfolge benutzt PUT auf /positions', () async {
String? methode;
Map<String, dynamic>? gesendet;
final dienst = await baue((anfrage) async {
methode = anfrage.method;
expect(anfrage.url.path, endsWith('/playlists/7/positions'));
gesendet = jsonDecode(anfrage.body) as Map<String, dynamic>;
return http.Response(jsonEncode({'status': 'ok'}), 200);
});
await dienst.setzePlaylistReihenfolge('7', ['c2', 'c1']);
expect(methode, 'PUT');
// Der Router liest „positions", der Handler erwartet Paare. Unter
// „song_ids" bekäme der Server eine leere Liste und antwortete stumm
// „ok" — die Reihenfolge käme nie an, ohne jede Fehlermeldung.
expect(gesendet, {
'positions': [
{'id': 'c2', 'position': 0},
{'id': 'c1', 'position': 1},
]
});
});
test('playlisten liest Name und ID', () async {
final dienst = await baue((_) async => http.Response(
jsonEncode({
'playlists': [
{'id': 7, 'name': 'Road Trip'}
]
}),
200,
));
final listen = await dienst.playlisten();
expect(listen.single.id, '7');
expect(listen.single.name, 'Road Trip');
});
test('playlistSongs liefert die Song-IDs in Reihenfolge', () async {
final dienst = await baue((_) async => http.Response(
jsonEncode({
'songs': [
{'id': 'c1'},
{'id': 'c2'},
]
}),
200,
));
expect(await dienst.playlistSongs('7'), ['c1', 'c2']);
});
}