use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::album::Album;
use super::clip::Clip;
use super::landing::Chart;
use super::misc::TrailerInfo;
use super::playlist::{CustomWave, Playlist, PlaylistId};
use super::track::Track;
use super::video::Video;
use super::{ContentRestrictions, Cover, CoverDerivedColors, ExtraAction, Id, Link, Pager};
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Counts {
pub tracks: Option<i64>,
pub direct_albums: Option<i64>,
pub also_albums: Option<i64>,
pub also_tracks: Option<i64>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Ratings {
pub month: Option<i64>,
pub week: Option<i64>,
pub day: Option<i64>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Description {
pub text: Option<String>,
pub uri: Option<String>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Stats {
pub last_month_listeners: Option<i64>,
pub last_month_listeners_delta: Option<i64>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Vinyl {
pub url: Option<String>,
pub title: Option<String>,
pub year: Option<i64>,
pub price: Option<f64>,
pub media: Option<String>,
pub offer_id: Option<i64>,
pub artist_ids: Vec<i64>,
pub picture: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Artist {
pub id: Option<Id>,
pub error: Option<String>,
pub reason: Option<String>,
pub name: Option<String>,
pub cover: Option<Cover>,
pub various: Option<bool>,
pub composer: Option<bool>,
pub genres: Vec<String>,
pub og_image: Option<String>,
pub op_image: Option<String>,
pub counts: Option<Counts>,
pub available: Option<bool>,
pub ratings: Option<Ratings>,
pub links: Vec<Link>,
pub tickets_available: Option<bool>,
pub likes_count: Option<i64>,
pub popular_tracks: Vec<Track>,
pub regions: Vec<String>,
pub hand_made_description: Option<String>,
pub description: Option<Description>,
pub countries: Vec<String>,
pub en_wikipedia_link: Option<String>,
pub db_aliases: Vec<String>,
pub init_date: Option<String>,
pub end_date: Option<String>,
pub ya_money_id: Option<String>,
pub disclaimers: Vec<String>,
pub content_restrictions: Option<ContentRestrictions>,
pub cutout_cover: Option<Cover>,
pub derived_colors: Option<CoverDerivedColors>,
pub has_trailer: Option<bool>,
pub no_pictures_from_search: Option<bool>,
pub timestamp: Option<String>,
pub trailer: Option<Value>,
pub donation_info: Option<Value>,
pub extra_actions: Vec<ExtraAction>,
pub decomposed: Option<Value>,
}
impl Artist {
#[must_use]
pub fn cover_url(&self, size: &str) -> Option<String> {
self.cover
.as_ref()
.and_then(|cover| cover.url(size))
.or_else(|| {
self.og_image
.as_deref()
.map(|uri| super::normalize_image_url(uri, size))
})
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistTracks {
pub tracks: Vec<Track>,
pub pager: Option<Pager>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistLink {
pub title: Option<String>,
pub subtitle: Option<String>,
pub url: Option<String>,
pub img_url: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistLinks {
pub links: Vec<ArtistLink>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistAlbums {
pub albums: Vec<Album>,
pub pager: Option<Pager>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistSimilar {
pub artist: Option<Artist>,
pub similar_artists: Vec<Artist>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistTrailer {
pub artist: Option<Artist>,
pub trailer: Option<TrailerInfo>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct BriefInfo {
pub artist: Option<Artist>,
pub albums: Vec<Album>,
pub playlists: Vec<Playlist>,
pub also_albums: Vec<Album>,
pub last_release_ids: Vec<i64>,
pub last_releases: Vec<Album>,
pub popular_tracks: Vec<Track>,
pub similar_artists: Vec<Artist>,
pub all_covers: Vec<Cover>,
pub concerts: Option<Value>,
pub videos: Vec<Video>,
pub vinyls: Vec<Vinyl>,
pub has_promotions: Option<bool>,
pub playlist_ids: Vec<PlaylistId>,
pub stats: Option<Stats>,
pub tracks_in_chart: Vec<Chart>,
pub bandlink_scanner_link: Option<String>,
pub clips: Vec<Clip>,
pub extra_actions: Vec<ExtraAction>,
pub custom_wave: Option<CustomWave>,
pub has_trailer: Option<bool>,
pub links: Vec<Link>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistDonationGoal {
pub title: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistDonationData {
pub tip_url: Option<String>,
pub artist: Option<Artist>,
pub goal: Option<ArtistDonationGoal>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistDonationItem {
pub r#type: Option<String>,
pub data: Option<ArtistDonationData>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistDonations {
pub donations: Vec<ArtistDonationItem>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistInfo {
pub artist: Option<Artist>,
pub likes_count: Option<i64>,
pub stats: Option<Stats>,
pub trailer: Option<Value>,
pub donation: Option<Value>,
pub covers: Vec<Cover>,
pub description: Option<String>,
pub artist_type: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistAbout {
pub artist: Option<Artist>,
pub donations: Vec<ArtistDonationItem>,
pub stats: Option<Stats>,
pub description: Option<String>,
pub links: Vec<Link>,
pub covers: Vec<Cover>,
pub artist_type: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistClipData {
pub clip: Option<Clip>,
pub artists: Vec<Artist>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistClipItem {
pub r#type: Option<String>,
pub data: Option<ArtistClipData>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistClips {
pub items: Vec<ArtistClipItem>,
pub pager: Option<Pager>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ArtistSkeleton {
pub id: Option<String>,
pub title: Option<String>,
pub blocks: Vec<Value>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn cover_urls_prefer_the_structured_cover_then_fall_back_to_og_image() {
let structured: Artist =
serde_json::from_str(r#"{"cover":{"uri":"c/%%"},"ogImage":"og/%%"}"#).unwrap();
assert_eq!(
structured.cover_url("50x50").as_deref(),
Some("https://c/50x50")
);
let og_only: Artist = serde_json::from_str(r#"{"ogImage":"og/%%"}"#).unwrap();
assert_eq!(
og_only.cover_url("50x50").as_deref(),
Some("https://og/50x50")
);
assert!(Artist::default().cover_url("50x50").is_none());
}
#[test]
fn a_full_brief_info_deserializes() {
let brief: BriefInfo = serde_json::from_str(
r#"{
"artist":{"id":1,"name":"A"},
"albums":[{"id":10}],
"popularTracks":[{"id":100}],
"similarArtists":[{"id":2}],
"stats":{"lastMonthListeners":5000},
"vinyls":[{"title":"LP","price":2500.0}],
"concerts":{"anything":true}
}"#,
)
.unwrap();
assert_eq!(brief.artist.unwrap().name.as_deref(), Some("A"));
assert_eq!(brief.albums.len(), 1);
assert_eq!(brief.stats.unwrap().last_month_listeners, Some(5000));
assert_eq!(brief.vinyls[0].price, Some(2500.0));
assert!(brief.concerts.is_some());
}
#[test]
fn artist_models_survive_an_empty_object() {
serde_json::from_str::<Artist>("{}").unwrap();
serde_json::from_str::<ArtistTracks>("{}").unwrap();
serde_json::from_str::<ArtistAlbums>("{}").unwrap();
serde_json::from_str::<ArtistLinks>("{}").unwrap();
serde_json::from_str::<ArtistSimilar>("{}").unwrap();
serde_json::from_str::<ArtistTrailer>("{}").unwrap();
serde_json::from_str::<BriefInfo>("{}").unwrap();
serde_json::from_str::<ArtistInfo>("{}").unwrap();
serde_json::from_str::<ArtistAbout>("{}").unwrap();
serde_json::from_str::<ArtistClips>("{}").unwrap();
serde_json::from_str::<ArtistDonations>("{}").unwrap();
serde_json::from_str::<ArtistSkeleton>("{}").unwrap();
serde_json::from_str::<Stats>("{}").unwrap();
serde_json::from_str::<Vinyl>("{}").unwrap();
}
}