use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::Id;
use super::album::Album;
use super::playlist::{GeneratedPlaylist, Playlist};
use super::track::{Track, TrackId};
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Promotion {
pub promo_id: Option<String>,
pub title: Option<String>,
pub subtitle: Option<String>,
pub heading: Option<String>,
pub url: Option<String>,
pub url_scheme: Option<String>,
pub text_color: Option<String>,
pub gradient: Option<String>,
pub image: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct TrackShortOld {
pub track_id: Option<TrackId>,
pub timestamp: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct PlayContext {
pub context: Option<String>,
pub context_item: Option<String>,
pub tracks: Vec<TrackShortOld>,
pub payload: Option<Value>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct MixLink {
pub title: Option<String>,
pub url: Option<String>,
pub url_scheme: Option<String>,
pub text_color: Option<String>,
pub background_color: Option<String>,
pub background_image_uri: Option<String>,
pub cover_white: Option<String>,
pub cover_uri: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Chart {
pub position: Option<i64>,
pub progress: Option<String>,
pub listeners: Option<i64>,
pub shift: Option<i64>,
pub bg_color: Option<String>,
pub track_id: Option<TrackId>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ChartItem {
pub track: Option<Track>,
pub chart: Option<Chart>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct ChartInfo {
pub id: Option<String>,
pub r#type: Option<String>,
pub type_for_from: Option<String>,
pub title: Option<String>,
pub menu: Option<Value>,
pub chart: Option<Playlist>,
pub chart_description: Option<String>,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub enum BlockEntityData {
PersonalPlaylist(Box<GeneratedPlaylist>),
Promotion(Box<Promotion>),
Album(Box<Album>),
Playlist(Box<Playlist>),
ChartItem(Box<ChartItem>),
PlayContext(Box<PlayContext>),
MixLink(Box<MixLink>),
Unknown(Value),
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct BlockEntity {
pub id: Option<String>,
pub r#type: Option<String>,
pub data: Option<Value>,
pub description: Option<String>,
pub description_formatted: Option<String>,
pub last_updated: Option<String>,
}
impl BlockEntity {
#[must_use]
pub fn data(&self) -> Option<BlockEntityData> {
let raw = self.data.clone()?;
let typed = |value: Value| -> Option<BlockEntityData> {
Some(match self.r#type.as_deref()? {
"personal-playlist" => {
BlockEntityData::PersonalPlaylist(Box::new(serde_json::from_value(value).ok()?))
},
"promotion" => {
BlockEntityData::Promotion(Box::new(serde_json::from_value(value).ok()?))
},
"album" => BlockEntityData::Album(Box::new(serde_json::from_value(value).ok()?)),
"playlist" => {
BlockEntityData::Playlist(Box::new(serde_json::from_value(value).ok()?))
},
"chart-item" => {
BlockEntityData::ChartItem(Box::new(serde_json::from_value(value).ok()?))
},
"play-context" => {
BlockEntityData::PlayContext(Box::new(serde_json::from_value(value).ok()?))
},
"mix-link" => {
BlockEntityData::MixLink(Box::new(serde_json::from_value(value).ok()?))
},
_ => return None,
})
};
Some(typed(raw.clone()).unwrap_or(BlockEntityData::Unknown(raw)))
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Block {
pub id: Option<String>,
pub r#type: Option<String>,
pub type_for_from: Option<String>,
pub title: Option<String>,
pub entities: Vec<BlockEntity>,
pub description: Option<String>,
pub data: Option<Value>,
pub background_image_url: Option<String>,
pub background_video_id: Option<String>,
pub background_video_url: Option<String>,
pub play_context: Option<Value>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Landing {
pub pumpkin: Option<bool>,
pub content_id: Option<Id>,
pub blocks: Vec<Block>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct LandingList {
pub r#type: Option<String>,
pub type_for_from: Option<String>,
pub title: Option<String>,
pub id: Option<String>,
pub new_releases: Vec<i64>,
pub new_playlists: Vec<Value>,
pub podcasts: Vec<i64>,
}
#[cfg(test)]
mod tests {
use super::*;
fn entity(json: &str) -> BlockEntity {
serde_json::from_str(json).unwrap()
}
#[test]
fn entity_payloads_resolve_by_their_type_tag() {
let album = entity(r#"{"type":"album","data":{"id":1,"title":"A"}}"#);
assert!(
matches!(album.data(), Some(BlockEntityData::Album(a)) if a.title.as_deref() == Some("A"))
);
let promo = entity(r#"{"type":"promotion","data":{"promoId":"p1"}}"#);
assert!(matches!(promo.data(), Some(BlockEntityData::Promotion(_))));
let personal = entity(r#"{"type":"personal-playlist","data":{"type":"playlistOfTheDay"}}"#);
assert!(matches!(
personal.data(),
Some(BlockEntityData::PersonalPlaylist(_))
));
let playlist = entity(r#"{"type":"playlist","data":{"kind":1}}"#);
assert!(matches!(
playlist.data(),
Some(BlockEntityData::Playlist(_))
));
let chart = entity(r#"{"type":"chart-item","data":{"chart":{"position":1}}}"#);
assert!(matches!(chart.data(), Some(BlockEntityData::ChartItem(_))));
let context = entity(r#"{"type":"play-context","data":{"context":"playlist"}}"#);
assert!(matches!(
context.data(),
Some(BlockEntityData::PlayContext(_))
));
let mix = entity(r#"{"type":"mix-link","data":{"title":"Mix"}}"#);
assert!(matches!(mix.data(), Some(BlockEntityData::MixLink(_))));
}
#[test]
fn an_unknown_type_keeps_its_payload_instead_of_dropping_it() {
let unknown = entity(r#"{"type":"brand-new-block","data":{"anything":[1,2]}}"#);
match unknown.data() {
Some(BlockEntityData::Unknown(value)) => {
assert_eq!(value, serde_json::json!({"anything": [1, 2]}));
},
other => panic!("expected Unknown, got {other:?}"),
}
}
#[test]
fn a_payload_that_does_not_match_its_type_degrades_to_unknown() {
let mismatched = entity(r#"{"type":"album","data":"not an object"}"#);
assert!(matches!(
mismatched.data(),
Some(BlockEntityData::Unknown(_))
));
}
#[test]
fn an_entity_without_a_payload_resolves_to_nothing() {
assert!(entity(r#"{"type":"album"}"#).data().is_none());
assert!(entity("{}").data().is_none());
}
#[test]
fn an_untagged_payload_is_preserved_as_unknown() {
let untagged = entity(r#"{"data":{"x":1}}"#);
assert!(matches!(untagged.data(), Some(BlockEntityData::Unknown(_))));
}
#[test]
fn a_landing_page_deserializes_with_its_blocks() {
let landing: Landing = serde_json::from_str(
r#"{"pumpkin":false,"contentId":"main","blocks":[{"id":"b1","entities":[{"type":"album","data":{"id":1}}]}]}"#,
)
.unwrap();
assert_eq!(landing.blocks.len(), 1);
assert_eq!(landing.blocks[0].entities.len(), 1);
assert_eq!(landing.content_id.unwrap().to_string(), "main");
}
#[test]
fn landing_models_survive_an_empty_object() {
serde_json::from_str::<Landing>("{}").unwrap();
serde_json::from_str::<Block>("{}").unwrap();
serde_json::from_str::<BlockEntity>("{}").unwrap();
serde_json::from_str::<LandingList>("{}").unwrap();
serde_json::from_str::<ChartInfo>("{}").unwrap();
serde_json::from_str::<Chart>("{}").unwrap();
serde_json::from_str::<ChartItem>("{}").unwrap();
serde_json::from_str::<Promotion>("{}").unwrap();
serde_json::from_str::<PlayContext>("{}").unwrap();
serde_json::from_str::<MixLink>("{}").unwrap();
}
}