use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::track::Track;
use super::{Icon, Id as ScalarId};
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct RestrictionValue {
pub value: Option<String>,
pub name: Option<String>,
pub image_url: Option<String>,
pub serialized_seed: Option<String>,
pub unspecified: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Enum {
pub r#type: Option<String>,
pub name: Option<String>,
pub possible_values: Vec<RestrictionValue>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct DiscreteScale {
pub r#type: Option<String>,
pub name: Option<String>,
pub min: Option<RestrictionValue>,
pub max: Option<RestrictionValue>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Restrictions {
pub language: Option<Enum>,
pub diversity: Option<Enum>,
pub mood: Option<DiscreteScale>,
pub energy: Option<DiscreteScale>,
pub mood_energy: Option<Enum>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct AdParams {
pub partner_id: Option<ScalarId>,
pub category_id: Option<ScalarId>,
pub page_ref: Option<String>,
pub target_ref: Option<String>,
pub other_params: Option<String>,
pub ad_volume: Option<i64>,
pub genre_id: Option<String>,
pub genre_name: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Id {
pub r#type: Option<String>,
pub tag: Option<String>,
}
impl Id {
#[must_use]
pub fn as_string(&self) -> Option<String> {
Some(format!(
"{}:{}",
self.r#type.as_deref()?,
self.tag.as_deref()?
))
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Station {
pub id: Option<Id>,
pub name: Option<String>,
pub icon: Option<Icon>,
pub mts_icon: Option<Icon>,
pub geocell_icon: Option<Icon>,
pub id_for_from: Option<String>,
pub restrictions: Option<Restrictions>,
pub restrictions2: Option<Restrictions>,
pub full_image_url: Option<String>,
pub mts_full_image_url: Option<String>,
pub parent_id: Option<Id>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct StationSettings {
pub language: Option<String>,
pub mood: Option<i64>,
pub energy: Option<i64>,
pub mood_energy: Option<String>,
pub diversity: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct StationResult {
pub station: Option<Station>,
pub settings: Option<StationSettings>,
pub settings2: Option<StationSettings>,
pub ad_params: Option<AdParams>,
pub explanation: Option<String>,
pub prerolls: Option<Value>,
pub rup_title: Option<String>,
pub rup_description: Option<String>,
pub custom_name: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Dashboard {
pub dashboard_id: Option<String>,
pub stations: Vec<StationResult>,
pub pumpkin: Option<bool>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct TrackParameters {
pub bpm: Option<f64>,
pub hue: Option<f64>,
pub energy: Option<f64>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Sequence {
pub r#type: Option<String>,
pub track: Option<Track>,
pub liked: Option<bool>,
pub track_parameters: Option<TrackParameters>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct StationTracksResult {
pub id: Option<Id>,
pub sequence: Vec<Sequence>,
pub batch_id: Option<String>,
pub pumpkin: Option<bool>,
pub radio_session_id: Option<String>,
}
impl StationTracksResult {
#[must_use]
pub fn tracks(&self) -> Vec<&Track> {
self.sequence
.iter()
.filter_map(|item| item.track.as_ref())
.collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn station_ids_compose_from_type_and_tag() {
let id = Id {
r#type: Some("genre".into()),
tag: Some("pop".into()),
};
assert_eq!(id.as_string().as_deref(), Some("genre:pop"));
assert!(Id::default().as_string().is_none());
}
#[test]
fn a_track_batch_exposes_its_tracks_in_order() {
let batch: StationTracksResult = serde_json::from_str(
r#"{"id":{"type":"user","tag":"onyourwave"},"batchId":"b1","sequence":[
{"type":"track","track":{"id":1},"liked":false,"trackParameters":{"bpm":128.0}},
{"type":"track","track":{"id":2}},
{"type":"ad"}
]}"#,
)
.unwrap();
assert_eq!(batch.tracks().len(), 2, "the ad slot carries no track");
assert_eq!(batch.batch_id.as_deref(), Some("b1"));
assert_eq!(batch.sequence[0].track_parameters.unwrap().bpm, Some(128.0));
}
#[test]
fn both_restriction_payloads_deserialize() {
let result: StationResult = serde_json::from_str(
r#"{"station":{"restrictions":{"mood":{"type":"discrete-scale","min":{"value":"1"},"max":{"value":"4"}}},
"restrictions2":{"moodEnergy":{"type":"enum","possibleValues":[{"value":"all","name":"All"}]}}},
"settings2":{"moodEnergy":"all","diversity":"default"}}"#,
)
.unwrap();
let station = result.station.unwrap();
assert!(station.restrictions.unwrap().mood.is_some());
let mood_energy = station.restrictions2.unwrap().mood_energy.unwrap();
assert_eq!(mood_energy.possible_values[0].name.as_deref(), Some("All"));
assert_eq!(
result.settings2.unwrap().mood_energy.as_deref(),
Some("all")
);
}
#[test]
fn ad_params_accept_both_id_shapes() {
let params: AdParams =
serde_json::from_str(r#"{"partnerId":123,"categoryId":"cat-7"}"#).unwrap();
assert_eq!(params.partner_id.unwrap().to_string(), "123");
assert_eq!(params.category_id.unwrap().to_string(), "cat-7");
}
#[test]
fn rotor_models_survive_an_empty_object() {
serde_json::from_str::<Dashboard>("{}").unwrap();
serde_json::from_str::<StationResult>("{}").unwrap();
serde_json::from_str::<StationTracksResult>("{}").unwrap();
serde_json::from_str::<Station>("{}").unwrap();
serde_json::from_str::<StationSettings>("{}").unwrap();
serde_json::from_str::<Restrictions>("{}").unwrap();
serde_json::from_str::<Sequence>("{}").unwrap();
serde_json::from_str::<AdParams>("{}").unwrap();
serde_json::from_str::<Id>("{}").unwrap();
serde_json::from_str::<Enum>("{}").unwrap();
serde_json::from_str::<DiscreteScale>("{}").unwrap();
serde_json::from_str::<RestrictionValue>("{}").unwrap();
}
}