use crate::client::Client;
use crate::difference::{DiffTrack, Difference};
use crate::error::Result;
use crate::models::{
GeneratedPlaylist, Playlist, PlaylistRecommendations, PlaylistSimilarEntities, PlaylistTrailer,
PlaylistsList, UserSettings,
};
use crate::params::Params;
use crate::types::{BatchObject, Visibility};
impl Client {
pub async fn user_settings(&self, user_id: Option<i64>) -> Result<UserSettings> {
let uid = self.resolve_uid(user_id)?;
let value = self
.get_value(&format!("/users/{uid}/settings"), Params::new())
.await?;
let settings = value.get("userSettings").cloned().unwrap_or(value);
self.decode(settings)
}
pub async fn user_playlist(
&self,
kind: impl std::fmt::Display,
user_id: Option<i64>,
) -> Result<Playlist> {
let uid = self.resolve_uid(user_id)?;
self.get(&format!("/users/{uid}/playlists/{kind}"), Params::new())
.await
}
pub async fn user_playlists(
&self,
kinds: impl IntoIterator<Item = impl std::fmt::Display>,
user_id: Option<i64>,
) -> Result<Vec<Playlist>> {
let uid = self.resolve_uid(user_id)?;
let form = Params::new().add_all("kinds", kinds);
self.post_form(&format!("/users/{uid}/playlists"), form)
.await
}
pub async fn user_playlists_list(&self, user_id: Option<i64>) -> Result<Vec<Playlist>> {
let uid = self.resolve_uid(user_id)?;
self.get(&format!("/users/{uid}/playlists/list"), Params::new())
.await
}
pub async fn user_playlist_kinds(&self, user_id: Option<i64>) -> Result<Vec<i64>> {
let uid = self.resolve_uid(user_id)?;
let value = self
.get_value(&format!("/users/{uid}/playlists/list/kinds"), Params::new())
.await?;
Ok(value
.as_array()
.map(|items| items.iter().filter_map(serde_json::Value::as_i64).collect())
.unwrap_or_default())
}
pub async fn playlist_recommendations(
&self,
kind: impl std::fmt::Display,
user_id: Option<i64>,
) -> Result<PlaylistRecommendations> {
let uid = self.resolve_uid(user_id)?;
self.get(
&format!("/users/{uid}/playlists/{kind}/recommendations"),
Params::new(),
)
.await
}
pub async fn playlist_trailer(
&self,
kind: impl std::fmt::Display,
user_id: Option<i64>,
) -> Result<PlaylistTrailer> {
let uid = self.resolve_uid(user_id)?;
self.get(
&format!("/users/{uid}/playlists/{kind}/trailer"),
Params::new(),
)
.await
}
pub async fn create_playlist(&self, title: &str, visibility: Visibility) -> Result<Playlist> {
let uid = self.resolve_uid(None)?;
let form = Params::new()
.add("title", title)
.add("visibility", visibility);
self.post_form(&format!("/users/{uid}/playlists/create"), form)
.await
}
pub async fn delete_playlist(&self, kind: impl std::fmt::Display) -> Result<bool> {
let uid = self.resolve_uid(None)?;
let value = self
.post_form_value(
&format!("/users/{uid}/playlists/{kind}/delete"),
Params::new(),
)
.await?;
Ok(Client::is_ok_response(&value))
}
pub async fn rename_playlist(
&self,
kind: impl std::fmt::Display,
name: &str,
) -> Result<Playlist> {
let uid = self.resolve_uid(None)?;
let form = Params::new().add("value", name);
self.post_form(&format!("/users/{uid}/playlists/{kind}/name"), form)
.await
}
pub async fn set_playlist_visibility(
&self,
kind: impl std::fmt::Display,
visibility: Visibility,
) -> Result<Playlist> {
let uid = self.resolve_uid(None)?;
let form = Params::new().add("value", visibility);
self.post_form(&format!("/users/{uid}/playlists/{kind}/visibility"), form)
.await
}
pub async fn set_playlist_description(
&self,
kind: impl std::fmt::Display,
description: &str,
) -> Result<Playlist> {
let uid = self.resolve_uid(None)?;
let form = Params::new().add("value", description);
self.post_form(&format!("/users/{uid}/playlists/{kind}/description"), form)
.await
}
pub async fn change_playlist(
&self,
kind: impl std::fmt::Display,
diff: &Difference,
revision: i64,
) -> Result<Playlist> {
let uid = self.resolve_uid(None)?;
let form = Params::new()
.add("kind", &kind)
.add("revision", revision)
.add("diff", diff.to_json());
self.post_form(&format!("/users/{uid}/playlists/{kind}/change"), form)
.await
}
pub async fn add_track_to_playlist(
&self,
kind: impl std::fmt::Display,
track_id: i64,
album_id: i64,
at: usize,
revision: i64,
) -> Result<Playlist> {
let diff = Difference::new().insert(at, [DiffTrack::new(track_id, album_id)]);
self.change_playlist(kind, &diff, revision).await
}
pub async fn remove_tracks_from_playlist(
&self,
kind: impl std::fmt::Display,
from: usize,
to: usize,
revision: i64,
) -> Result<Playlist> {
let diff = Difference::new().delete(from, to);
self.change_playlist(kind, &diff, revision).await
}
pub async fn join_collective_playlist(&self, owner_uid: i64, token: &str) -> Result<bool> {
let params = Params::new().add("uid", owner_uid).add("token", token);
let query: Vec<(&str, &str)> = params.pairs().collect();
let encoded = serde_urlencoded_lite(&query);
let value = self
.post_form_value(
&format!("/playlists/collective/join?{encoded}"),
Params::new(),
)
.await?;
Ok(Client::is_ok_response(&value))
}
pub async fn playlist_by_uuid(&self, playlist_uuid: &str) -> Result<Playlist> {
self.get(&format!("/playlist/{playlist_uuid}"), Params::new())
.await
}
pub async fn playlist_similar_entities(
&self,
playlist_uuid: &str,
) -> Result<PlaylistSimilarEntities> {
self.get(
&format!("/playlist/{playlist_uuid}/similar-entities"),
Params::new(),
)
.await
}
pub async fn playlists(
&self,
playlist_ids: impl IntoIterator<Item = impl std::fmt::Display>,
) -> Result<PlaylistsList> {
let joined = playlist_ids
.into_iter()
.map(|id| id.to_string())
.collect::<Vec<_>>()
.join(",");
self.get("/playlists", Params::new().add("playlistIds", joined))
.await
}
pub async fn playlists_list(
&self,
playlist_ids: impl IntoIterator<Item = impl std::fmt::Display>,
) -> Result<Vec<Playlist>> {
self.get_batch(BatchObject::Playlist, playlist_ids, Params::new())
.await
}
pub async fn personal_playlist(&self, playlist_id: &str) -> Result<GeneratedPlaylist> {
self.get(&format!("/playlists/personal/{playlist_id}"), Params::new())
.await
}
}
fn serde_urlencoded_lite(pairs: &[(&str, &str)]) -> String {
fn encode(value: &str) -> String {
value
.bytes()
.map(|byte| match byte {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
(byte as char).to_string()
},
other => format!("%{other:02X}"),
})
.collect()
}
pairs
.iter()
.map(|(key, value)| format!("{}={}", encode(key), encode(value)))
.collect::<Vec<_>>()
.join("&")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn query_pairs_are_percent_encoded() {
assert_eq!(
serde_urlencoded_lite(&[("uid", "123"), ("token", "a b&c=d")]),
"uid=123&token=a%20b%26c%3Dd"
);
}
#[test]
fn unreserved_characters_survive_encoding_unchanged() {
assert_eq!(serde_urlencoded_lite(&[("k", "aZ09-_.~")]), "k=aZ09-_.~");
}
#[test]
fn an_empty_pair_list_encodes_to_an_empty_string() {
assert_eq!(serde_urlencoded_lite(&[]), "");
}
}