use std::sync::Arc; use crate::auth::Credentials; use crate::clips::{self, Clip, LikedEntry}; use crate::library::{ AlbumPage, AlbumSummary, ArtistPage, ArtistSummary, LibraryPlaylists, PlaylistId, PlaylistPage, PlaylistSummary, }; use crate::edit::{LikedIds, Lyrics, QueueContext}; use crate::discover::{ChartEntry, Genre, Home, SearchKind, SearchResults}; use crate::models::{Stream, Track, best_variant, file_info_stream}; use crate::wave::{PlayReport, Station, WaveBatch, WaveEvent, WaveSettings, iso_millis, numeric_id}; use crate::{Error, Result}; /// Playlist diffs need numeric track and album ids. fn diff_ids(track: &Track) -> Result<(i64, i64)> { let id = crate::wave::numeric_id(&track.id).ok_or_else(|| Error::Api("this track can't go in a playlist".into()))?; let album = track.album.as_ref().map(|a| a.id).ok_or_else(|| Error::Api("track has no album".into()))?; Ok((id, album)) } /// How many featured podcasts to resolve. pub const FEATURED_PODCASTS: usize = 48; /// Playlist ids from `/tags/{id}/playlist-ids`: `{"ids":[{"uid":1,"kind":2}]}`, /// tolerating the `"uid:kind"` string form too. fn tag_playlist_ids(raw: &serde_json::Value) -> Vec { let ids = raw.get("result").unwrap_or(raw).get("ids").and_then(|v| v.as_array()); ids.into_iter() .flatten() .filter_map(|id| match id { serde_json::Value::String(s) if s.contains(':') => Some(s.clone()), serde_json::Value::Object(o) => { Some(format!("{}:{}", o.get("uid")?.as_i64()?, o.get("kind")?.as_i64()?)) } _ => None, }) .collect() } /// A queue id, unless it's the all-zero placeholder Yandex returns for a queue it didn't keep. fn real_queue_id(id: Option) -> Option { id.filter(|id| !id.is_empty() && !id.bytes().all(|b| b == b'0')) } /// The signed-in user as the UI needs them. #[derive(Debug, Clone, PartialEq, Eq)] pub struct Account { pub uid: i64, pub login: String, /// Best human-readable name: display name, then full name, then login. pub name: String, /// Yandex Plus unlocks full-length tracks; without it the API serves 30-second previews. pub has_plus: bool, /// When the current subscription ends, as Yandex formats it (ISO 8601). pub subscription_end: Option, } impl Account { /// One letter for the avatar. pub fn initial(&self) -> char { self.name.chars().find(|c| c.is_alphanumeric()).map_or('?', |c| { c.to_uppercase().next().unwrap_or(c) }) } fn from_status(status: yamuse::models::Status) -> Option { let account = status.account?; let uid = account.uid?; let login = account.login.unwrap_or_default(); let non_empty = |s: Option| s.filter(|s| !s.trim().is_empty()); let name = non_empty(account.display_name) .or_else(|| non_empty(account.full_name)) .unwrap_or_else(|| login.clone()); Some(Self { uid, login, name, has_plus: status.plus.and_then(|p| p.has_plus).unwrap_or(false), subscription_end: status.subscription.and_then(|s| { s.end.or_else(|| s.auto_renewable.into_iter().find_map(|a| a.expires)) }), }) } } /// An authenticated API client. Cheap to clone. #[derive(Clone)] pub struct YmClient { inner: yamuse::Client, /// Kept for the few JSON endpoints yamuse doesn't expose. Never printed. token: Option>, } impl std::fmt::Debug for YmClient { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.debug_struct("YmClient").finish_non_exhaustive() } } impl YmClient { /// Builds a client for `credentials` and loads the account. Fails with /// [`crate::Error::Unauthorized`] when the token is no longer valid. pub async fn connect(credentials: &Credentials) -> Result<(Self, Account)> { let inner = yamuse::Client::builder().token(&credentials.access_token).build()?; let status = inner.refresh_account().await?; let account = Account::from_status(status) .ok_or_else(|| Error::Unauthorized("account status has no user".into()))?; Ok((Self { inner, token: Some(credentials.access_token.as_str().into()) }, account)) } /// A client with no token, for previews and tests. Every account call fails. pub fn unauthenticated() -> Result { Ok(Self { inner: yamuse::Client::anonymous()?, token: None }) } /// The user's liked tracks, newest like first, with full metadata. pub async fn liked_tracks(&self) -> Result> { let list = self.inner.liked_tracks(None).await?; let ids: Vec = list .tracks .into_iter() .filter_map(|short| { let id = match short.id? { yamuse::models::Id::Number(n) => n.to_string(), yamuse::models::Id::Text(s) => s, }; Some(match short.album_id { Some(album) if !id.contains(':') => format!("{id}:{album}"), _ => id, }) }) .collect(); self.tracks(ids).await } /// Full metadata for `ids` (`"trackId"` or `"trackId:albumId"`), in the given order. pub async fn tracks(&self, ids: Vec) -> Result> { if ids.is_empty() { return Ok(Vec::new()); } let tracks = self.inner.tracks(&ids).await?; Ok(tracks.into_iter().filter_map(Track::from_yamuse).collect()) } /// Resolves a signed, short-lived audio URL for a track, at most `max_kbps` when set. pub async fn stream(&self, track_id: &str, max_kbps: Option) -> Result { let variants = self.inner.track_download_info(track_id).await?; let variant = best_variant(&variants, max_kbps) .ok_or_else(|| Error::Api(format!("no playable variant for track {track_id}")))?; let url = variant.direct_link(self.inner.transport()).await?; Ok(Stream { urls: vec![url], codec: variant.codec.clone().unwrap_or_default(), bitrate_kbps: variant.bitrate_in_kbps.unwrap_or(0).max(0) as u32, preview: variant.preview.unwrap_or(false), key: None, }) } /// FLAC when Yandex grants it for this track and account. Otherwise Yandex /// answers with the best lossy file it allows (often AAC 192), which is played /// as is unless it's HE-AAC, which the decoder can't do justice; then the MP3 /// path, as [`stream`](Self::stream) with no cap. pub async fn lossless_stream(&self, track_id: &str) -> Result { match self.inner.track_lossless_info(track_id, "lossless").await.map_err(Error::from) { Ok(info) => { if let Some(stream) = file_info_stream(info) { return Ok(stream); } } Err(e @ (Error::Unauthorized(_) | Error::Network(_))) => return Err(e), // An API refusal (region, rights) still leaves the MP3 path. Err(_) => {} } self.stream(track_id, None).await } /// Downloads a whole stream into memory, decrypting it when it is encrypted /// (MP3 320 is about 10 MB a track, FLAC 30–60 MB). pub async fn fetch(&self, stream: &Stream) -> Result> { let bytes = yamuse::download::Downloader::new(self.inner.transport(), stream.urls.iter().cloned()) .maybe_encraw_key(stream.key.clone()) .to_bytes() .await?; Ok(bytes.into()) } /// Albums the user liked, newest first, with full details. pub async fn liked_albums(&self) -> Result> { let likes = self.inner.liked_albums(None).await?; let ids: Vec = likes .into_iter() .filter_map(|like| like.album.and_then(|a| a.id).or_else(|| like.id.and_then(|i| i.as_number()))) .collect(); if ids.is_empty() { return Ok(Vec::new()); } let albums = self.inner.albums(&ids).await?; Ok(albums.into_iter().filter_map(AlbumSummary::from_yamuse).collect()) } pub async fn liked_artists(&self) -> Result> { let artists = self.inner.liked_artists(None).await?; Ok(artists.into_iter().filter_map(ArtistSummary::from_yamuse).collect()) } /// Playlists the user owns, and ones they liked. pub async fn library_playlists(&self) -> Result { let own = self.inner.user_playlists_list(None).await?; let likes = self.inner.liked_playlists(None).await?; let liked_ids: Vec = likes .iter() .filter_map(|like| { let p = like.playlist.as_ref()?; let owner = p.uid.or_else(|| p.owner.as_ref().and_then(|o| o.uid))?; Some(format!("{owner}:{}", p.kind?)) }) .collect(); let liked = if liked_ids.is_empty() { Vec::new() } else { self.inner.playlists_list(&liked_ids).await? }; Ok(LibraryPlaylists { own: own.iter().filter_map(PlaylistSummary::from_yamuse).collect(), liked: liked.iter().filter_map(PlaylistSummary::from_yamuse).collect(), }) } pub async fn album(&self, id: i64) -> Result { let album = self.inner.album_with_tracks(id).await?; AlbumPage::from_yamuse(album).ok_or_else(|| Error::Api(format!("album {id} has no id"))) } pub async fn artist(&self, id: i64) -> Result { let brief = self.inner.artist_brief_info(id).await?; let mut page = ArtistPage::from_yamuse(brief).ok_or_else(|| Error::Api(format!("artist {id} not found")))?; // The page is still worth showing without its videos. match self.artist_clips(id).await { Ok(clips) => page.clips = clips, Err(e) => eprintln!("artist clips: {e}"), } Ok(page) } /// A playlist with all its tracks. Tracks the response didn't embed are looked up. pub async fn playlist(&self, id: PlaylistId) -> Result { let raw = self.inner.user_playlist(id.kind, Some(id.owner)).await?; let playlist = PlaylistSummary::from_yamuse(&raw) .ok_or_else(|| Error::Api(format!("playlist {}:{} incomplete", id.owner, id.kind)))?; let mut tracks: Vec> = Vec::with_capacity(raw.tracks.len()); let mut missing = Vec::new(); for (i, short) in raw.tracks.into_iter().enumerate() { match short.track.and_then(Track::from_yamuse) { Some(track) => tracks.push(Some(track)), None => { if let Some(id) = short.id { let id = match id { yamuse::models::Id::Number(n) => n.to_string(), yamuse::models::Id::Text(s) => s, }; missing.push((i, id)); } tracks.push(None); } } } if !missing.is_empty() { let fetched = self.tracks(missing.iter().map(|(_, id)| id.clone()).collect()).await?; for ((slot, _), track) in missing.iter().zip(fetched) { tracks[*slot] = Some(track); } } Ok(PlaylistPage { playlist, description: raw.description.filter(|d| !d.trim().is_empty()), tracks: tracks.into_iter().flatten().collect(), }) } /// One page of search results. `page` starts at 0. pub async fn search(&self, text: &str, kind: SearchKind, page: u32) -> Result { let mut query = yamuse::SearchQuery::default().of_type(kind.to_yamuse()); query.page = page; Ok(SearchResults::from_yamuse(self.inner.search(text, query).await?)) } /// Completions for a partial query, best first. pub async fn suggest(&self, part: &str) -> Result> { Ok(self.inner.search_suggest(part).await?.suggestions) } /// The home page: personal playlists, new releases and playlists, the chart. pub async fn home(&self) -> Result { let landing = self .inner .landing(["personalplaylists", "new-releases", "new-playlists"]) .await?; let mut home = Home::from_landing(landing); // The chart block on landing3 holds a handful of items; the chart endpoint has them all. match self.chart().await { Ok(chart) if !chart.is_empty() => home.chart = chart, Ok(_) => {} Err(e) => eprintln!("chart: {e}"), } Ok(home) } pub async fn chart(&self) -> Result> { let info = self.inner.chart().await?; Ok(info .chart .map(|p| p.tracks.into_iter().filter_map(ChartEntry::from_short).collect()) .unwrap_or_default()) } pub async fn genres(&self) -> Result> { Ok(self.inner.genres().await?.into_iter().filter_map(Genre::from_yamuse).collect()) } /// Editorial playlists filed under a genre or mood tag. pub async fn tag_playlists(&self, tag: &str) -> Result> { // yamuse types these ids as strings; the API sends `{uid, kind}` objects. let raw = self .inner .get_raw(&format!("/tags/{tag}/playlist-ids"), yamuse::Params::new()) .await?; let ids = tag_playlist_ids(&raw); if ids.is_empty() { return Ok(Vec::new()); } let playlists = self.inner.playlists_list(&ids).await?; Ok(playlists.iter().filter_map(PlaylistSummary::from_yamuse).collect()) } /// Podcasts Yandex currently features (the first [`FEATURED_PODCASTS`]; the list runs to thousands). pub async fn featured_podcasts(&self) -> Result> { let mut ids = self.inner.podcasts().await?.podcasts; ids.truncate(FEATURED_PODCASTS); if ids.is_empty() { return Ok(Vec::new()); } let albums = self.inner.albums(&ids).await?; Ok(albums.into_iter().filter_map(AlbumSummary::from_yamuse).collect()) } /// Stations Yandex suggests to this user. pub async fn stations(&self) -> Result> { let dashboard = self.inner.rotor_dashboard().await?; Ok(dashboard.stations.into_iter().filter_map(Station::from_yamuse).collect()) } pub async fn wave_settings(&self, station: &str) -> Result { let info = self.inner.rotor_station_info(station).await?; Ok(info .into_iter() .next() .and_then(|r| r.settings2.or(r.settings)) .map(|s| WaveSettings::from_api(&s)) .unwrap_or_default()) } pub async fn set_wave_settings(&self, station: &str, settings: WaveSettings) -> Result<()> { let (mood, diversity, language) = settings.to_yamuse(); self.inner .rotor_set_station_settings(station, mood, diversity, language, yamuse::StationType::Rotor) .await?; Ok(()) } /// Starts a station session. My Wave's settings travel as extra seeds. pub async fn wave_start(&self, station: &str, settings: Option) -> Result { let mut seeds = vec![station.to_owned()]; seeds.extend(settings.map(WaveSettings::seeds).unwrap_or_default()); let body = serde_json::json!({ "seeds": seeds, "includeTracksInResponse": true }); Ok(WaveBatch::from_session(&self.post_json("/rotor/session/new", &body).await?)) } /// The next batch of a session. `queue` is the recently queued tracks (`full_id`s). pub async fn wave_more(&self, session_id: &str, queue: &[String]) -> Result { let body = serde_json::json!({ "queue": queue }); let path = format!("/rotor/session/{session_id}/tracks"); let mut batch = WaveBatch::from_session(&self.post_json(&path, &body).await?); batch.session_id.get_or_insert_with(|| session_id.to_owned()); Ok(batch) } /// Tells a session what happened, so the next batch fits better. pub async fn wave_feedback(&self, session_id: &str, event: &WaveEvent, batch_id: Option<&str>) -> Result<()> { let now = iso_millis(std::time::SystemTime::now()); let mut body = serde_json::json!({ "event": event.to_json(&now) }); if let Some(batch) = batch_id { body["batchId"] = batch.into(); } if matches!(event, WaveEvent::Started) { body["from"] = "musyx-wave".into(); } self.post_json(&format!("/rotor/session/{session_id}/feedback"), &body).await?; Ok(()) } /// POSTs JSON with the same identity headers yamuse sends, returning `result`. async fn post_json(&self, path: &str, body: &serde_json::Value) -> Result { let token = self.token.as_deref().ok_or_else(|| Error::Unauthorized("not signed in".into()))?; let response = self .inner .transport() .http() .post(format!("{}{path}", self.inner.base_url())) .header("Authorization", format!("OAuth {token}")) .header("X-Yandex-Music-Client", yamuse::transport::CLIENT_HEADER) .header("Content-Type", "application/json") .body(body.to_string()) .send() .await .map_err(|e| Error::Network(e.to_string()))?; let status = response.status().as_u16(); let text = response.text().await.map_err(|e| Error::Network(e.to_string()))?; let value: serde_json::Value = serde_json::from_str(&text).unwrap_or(serde_json::Value::Null); match status { 200..=299 => Ok(value.get("result").cloned().unwrap_or(value)), 401 | 403 => Err(Error::Unauthorized(format!("{path}: {status}"))), 500.. => Err(Error::Network(format!("{path}: {status}"))), _ => { let message = value .pointer("/error/message") .or_else(|| value.pointer("/error/name")) .and_then(|m| m.as_str()) .unwrap_or(&text); Err(Error::Api(format!("{path}: {status} {message}"))) } } } /// Records a listen in the user's history. Tracks without numeric ids are skipped. pub async fn report_play(&self, report: &PlayReport) -> Result<()> { let Some(track_id) = numeric_id(&report.track_id) else { return Ok(()) }; let mut r = yamuse::PlayAudioReport::new(track_id, report.album_id.unwrap_or(0), report.from.clone()); r.track_length_seconds = report.length.as_secs(); r.total_played_seconds = report.played.as_secs(); r.end_position_seconds = report.end_position.as_secs(); // yamuse's default timestamps drop the milliseconds, which the endpoint rejects. let now = iso_millis(std::time::SystemTime::now()); r.timestamp = Some(now.clone()); r.client_now = Some(now); self.inner.play_audio(&r).await?; Ok(()) } // ---- Clips ---- /// An artist's music videos, newest first (the first 50). pub async fn artist_clips(&self, artist_id: i64) -> Result> { let raw = self .inner .get_raw(&format!("/artists/{artist_id}/blocks/artist-clips"), yamuse::Params::new()) .await?; Ok(clips::artist_block(&raw)) } /// Every clip the user liked, newest first. Bare references are looked up. pub async fn liked_clips(&self) -> Result> { const PAGE: u64 = 100; let uid = self.inner.account_uid().ok_or_else(|| Error::Unauthorized("not signed in".into()))?; let mut entries = Vec::new(); for page in 0..20 { let params = yamuse::Params::new().add("page", page).add("pageSize", PAGE); let raw = self.inner.get_raw(&format!("/users/{uid}/likes/clips"), params).await?; entries.extend(clips::liked_page(&raw)); if !clips::has_more(&raw, page) { break; } } let missing: Vec = entries.iter().filter_map(|e| if let LikedEntry::Id(id) = e { Some(*id) } else { None }).collect(); let mut found: std::collections::HashMap = std::collections::HashMap::new(); for chunk in missing.chunks(PAGE as usize) { let ids = chunk.iter().map(i64::to_string).collect::>().join(","); let raw = self.inner.get_raw("/clips", yamuse::Params::new().add("clipIds", ids)).await?; for v in raw.as_array().into_iter().flatten() { if let Some(clip) = Clip::from_value(v, None) { found.insert(clip.id, clip); } } } Ok(entries .into_iter() .filter_map(|e| match e { LikedEntry::Full(clip) => Some(clip), LikedEntry::Id(id) => found.remove(&id), }) .collect()) } pub async fn set_clip_liked(&self, id: i64, liked: bool) -> Result<()> { if liked { self.inner.like_clip(id).await?; } else { self.inner.unlike_clip(id).await?; } Ok(()) } // ---- Likes ---- /// Track ids are `full_id`s or plain ids; Yandex accepts both. pub async fn set_track_liked(&self, track_id: &str, liked: bool) -> Result<()> { self.inner.set_liked(yamuse::Likeable::Track, [track_id], liked, None).await?; Ok(()) } /// "Don't recommend": the track stops appearing in waves and mixes. pub async fn set_track_disliked(&self, track_id: &str, disliked: bool) -> Result<()> { self.inner.set_disliked(yamuse::Dislikeable::Track, [track_id], disliked, None).await?; Ok(()) } pub async fn set_album_liked(&self, id: i64, liked: bool) -> Result<()> { self.inner.set_liked(yamuse::Likeable::Album, [id], liked, None).await?; Ok(()) } pub async fn set_artist_liked(&self, id: i64, liked: bool) -> Result<()> { self.inner.set_liked(yamuse::Likeable::Artist, [id], liked, None).await?; Ok(()) } pub async fn set_playlist_liked(&self, id: PlaylistId, liked: bool) -> Result<()> { let key = format!("{}:{}", id.owner, id.kind); self.inner.set_liked(yamuse::Likeable::Playlist, [key], liked, None).await?; Ok(()) } /// Ids only (no details), for drawing like state on every page. pub async fn liked_ids(&self) -> Result { let albums = self.inner.liked_albums(None).await?; let artists = self.inner.liked_artists(None).await?; let playlists = self.inner.liked_playlists(None).await?; let disliked = self.inner.disliked_tracks(None).await?; // Clips are optional: a failure here shouldn't hide every other heart. let clips = match self.liked_clips().await { Ok(clips) => clips.into_iter().map(|c| c.id).collect(), Err(e @ Error::Unauthorized(_)) => return Err(e), Err(e) => { eprintln!("liked clips: {e}"); Default::default() } }; Ok(LikedIds { clips, albums: albums .into_iter() .filter_map(|l| l.album.and_then(|a| a.id).or_else(|| l.id.and_then(|i| i.as_number()))) .collect(), artists: artists.into_iter().filter_map(|a| a.id.and_then(|i| i.as_number())).collect(), playlists: playlists .into_iter() .filter_map(|l| { let p = l.playlist?; Some(PlaylistId { owner: p.uid.or_else(|| p.owner.and_then(|o| o.uid))?, kind: p.kind? }) }) .collect(), disliked_tracks: disliked .tracks .into_iter() .filter_map(|t| match t.id? { yamuse::models::Id::Number(n) => Some(n.to_string()), yamuse::models::Id::Text(s) => s.split(':').next().map(str::to_owned), }) .collect(), }) } // ---- Playlists ---- pub async fn create_playlist(&self, title: &str, public: bool) -> Result { let visibility = if public { yamuse::Visibility::Public } else { yamuse::Visibility::Private }; let p = self.inner.create_playlist(title, visibility).await?; PlaylistSummary::from_yamuse(&p).ok_or_else(|| Error::Api("created playlist has no id".into())) } pub async fn rename_playlist(&self, id: PlaylistId, title: &str) -> Result<()> { self.inner.rename_playlist(id.kind, title).await?; Ok(()) } pub async fn set_playlist_public(&self, id: PlaylistId, public: bool) -> Result<()> { let visibility = if public { yamuse::Visibility::Public } else { yamuse::Visibility::Private }; self.inner.set_playlist_visibility(id.kind, visibility).await?; Ok(()) } pub async fn delete_playlist(&self, id: PlaylistId) -> Result<()> { self.inner.delete_playlist(id.kind).await?; Ok(()) } /// The playlist's revision and length, which every edit needs fresh. async fn revision(&self, id: PlaylistId) -> Result<(i64, usize)> { let p = self.inner.user_playlist(id.kind, Some(id.owner)).await?; let len = p.track_count.map_or(p.tracks.len(), |n| n.max(0) as usize); Ok((p.revision.unwrap_or(0), len)) } /// Appends a track to the end of one of the user's playlists. pub async fn add_to_playlist(&self, id: PlaylistId, track: &Track) -> Result<()> { let (track_id, album_id) = diff_ids(track)?; let (revision, len) = self.revision(id).await?; self.inner.add_track_to_playlist(id.kind, track_id, album_id, len, revision).await?; Ok(()) } /// Removes the track at `index`. pub async fn remove_from_playlist(&self, id: PlaylistId, index: usize) -> Result<()> { let (revision, _) = self.revision(id).await?; self.inner.remove_tracks_from_playlist(id.kind, index, index + 1, revision).await?; Ok(()) } /// Moves the track at `from` so it ends up at `to`. pub async fn move_in_playlist(&self, id: PlaylistId, track: &Track, from: usize, to: usize) -> Result<()> { let (track_id, album_id) = diff_ids(track)?; let (revision, _) = self.revision(id).await?; let diff = yamuse::Difference::new() .delete(from, from + 1) .insert(to, [yamuse::DiffTrack::new(track_id, album_id)]); self.inner.change_playlist(id.kind, &diff, revision).await?; Ok(()) } // ---- Lyrics ---- /// Synced lyrics when Yandex has them, else plain text; `None` when there are none. pub async fn lyrics(&self, track_id: &str) -> Result> { for format in [yamuse::LyricsFormat::Lrc, yamuse::LyricsFormat::Text] { let meta = match self.inner.track_lyrics(track_id, format).await { Ok(meta) => meta, Err(yamuse::Error::NotFound(_)) => continue, Err(e) => return Err(e.into()), }; let text = meta.text(self.inner.transport()).await?; if text.trim().is_empty() { continue; } let writers = meta.writers.clone(); return Ok(Some(match format { yamuse::LyricsFormat::Lrc => Lyrics::from_lrc(&text, writers), yamuse::LyricsFormat::Text => Lyrics::from_text(&text, writers), })); } Ok(None) } // ---- Server queue ---- /// Publishes what's playing so other devices can continue it. Returns the queue id, /// or `None` when Yandex didn't keep the queue. /// /// Yandex now answers every create with the placeholder id `000000000000000000000000` /// and lists no queues afterwards, whatever device header is sent (a stable /// `device_id` was tried): the phone apps sync through Ynison instead. The /// placeholder is dropped so no position updates go to a queue that doesn't exist. pub async fn create_queue(&self, context: &QueueContext, tracks: &[Track], current: usize) -> Result> { let tracks: Vec = tracks .iter() .map(|t| { serde_json::json!({ "trackId": t.id.split(':').next().unwrap_or(&t.id), "albumId": t.album.as_ref().map(|a| a.id.to_string()).unwrap_or_default(), "from": "musyx-desktop", }) }) .collect(); let body = serde_json::json!({ "context": context.to_json(), "tracks": tracks, "currentIndex": current, "from": "musyx-desktop", "isInteractive": true, }); Ok(real_queue_id(self.inner.create_queue(&body, None).await?)) } pub async fn update_queue_position(&self, queue_id: &str, index: usize) -> Result<()> { self.inner.update_queue_position(queue_id, index as i64, None).await?; Ok(()) } /// Downloads an image (covers are a few kilobytes). pub async fn image(&self, url: &str) -> Result> { Ok(yamuse::download::Downloader::new(self.inner.transport(), [url.to_owned()]) .to_bytes() .await?) } /// Re-reads the account, e.g. after a subscription may have changed. pub async fn account(&self) -> Result { let status = self.inner.refresh_account().await?; Account::from_status(status) .ok_or_else(|| Error::Unauthorized("account status has no user".into())) } } #[cfg(test)] mod tests { use super::*; fn status(json: &str) -> yamuse::models::Status { serde_json::from_str(json).unwrap() } #[test] fn account_prefers_display_name_and_reads_plus() { let a = Account::from_status(status( r#"{"account":{"uid":42,"login":"yuriy.panov","displayName":"Юрий","fullName":"Юрий Панов"}, "plus":{"hasPlus":true},"subscription":{"end":"2027-01-01T00:00:00+03:00"}}"#, )) .unwrap(); assert_eq!(a.uid, 42); assert_eq!(a.name, "Юрий"); assert_eq!(a.initial(), 'Ю'); assert!(a.has_plus); assert_eq!(a.subscription_end.as_deref(), Some("2027-01-01T00:00:00+03:00")); } #[test] fn account_falls_back_to_login_and_no_plus() { let a = Account::from_status(status( r#"{"account":{"uid":7,"login":"listener","displayName":" "}}"#, )) .unwrap(); assert_eq!(a.name, "listener"); assert!(!a.has_plus); assert_eq!(a.subscription_end, None); } #[test] fn tag_ids_accept_objects_and_strings() { let raw = serde_json::json!({"ids": [{"uid": 1, "kind": 2}, "3:4", null, {"uid": 5}]}); assert_eq!(tag_playlist_ids(&raw), vec!["1:2", "3:4"]); let wrapped = serde_json::json!({"result": {"ids": [{"uid": 9, "kind": 8}]}}); assert_eq!(tag_playlist_ids(&wrapped), vec!["9:8"]); } #[test] fn placeholder_queue_ids_are_dropped() { assert_eq!(real_queue_id(Some("000000000000000000000000".into())), None); assert_eq!(real_queue_id(Some(String::new())), None); assert_eq!(real_queue_id(None), None); assert_eq!(real_queue_id(Some("6702a1f0c3".into())).as_deref(), Some("6702a1f0c3")); } #[test] fn anonymous_status_is_not_an_account() { assert!(Account::from_status(status(r#"{"account":{"now":"2026-10-15"}}"#)).is_none()); assert!(Account::from_status(status("{}")).is_none()); } }