use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::user::User;
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Permissions {
pub until: Option<String>,
pub values: Vec<String>,
pub default: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Plus {
pub has_plus: Option<bool>,
pub is_tutorial_completed: Option<bool>,
pub migrated: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Price {
pub amount: Option<f64>,
pub currency: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct LicenceTextPart {
pub text: Option<String>,
pub url: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Product {
pub product_id: Option<String>,
pub r#type: Option<String>,
pub duration: Option<i64>,
pub trial_duration: Option<i64>,
pub feature: Option<String>,
pub debug: Option<bool>,
pub plus: Option<bool>,
pub price: Option<Price>,
pub common_period_duration: Option<String>,
pub cheapest: Option<bool>,
pub title: Option<String>,
pub family_sub: Option<bool>,
pub fb_image: Option<String>,
pub fb_name: Option<String>,
pub family: Option<bool>,
pub features: Vec<String>,
pub description: Option<String>,
pub available: Option<bool>,
pub trial_available: Option<bool>,
pub trial_period_duration: Option<String>,
pub intro_period_duration: Option<String>,
pub intro_price: Option<Price>,
pub start_period_duration: Option<String>,
pub start_price: Option<Price>,
pub licence_text_parts: Vec<LicenceTextPart>,
pub vendor_trial_available: Option<bool>,
pub button_text: Option<String>,
pub button_additional_text: Option<String>,
pub payment_method_types: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct AutoRenewable {
pub expires: Option<String>,
pub vendor: Option<String>,
pub vendor_help_url: Option<String>,
pub product: Option<Product>,
pub finished: Option<bool>,
pub master_info: Option<User>,
pub product_id: Option<String>,
pub order_id: Option<i64>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct NonAutoRenewable {
pub start: Option<String>,
pub end: Option<String>,
}
#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct RenewableRemainder {
pub days: Option<i64>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Deactivation {
pub method: Option<String>,
pub instructions: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Operator {
pub product_id: Option<String>,
pub phone: Option<String>,
pub payment_regularity: Option<String>,
pub deactivation: Vec<Deactivation>,
pub title: Option<String>,
pub suspended: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Subscription {
pub non_auto_renewable_remainder: Option<RenewableRemainder>,
pub auto_renewable: Vec<AutoRenewable>,
pub family_auto_renewable: Vec<AutoRenewable>,
pub had_any_subscription: Option<bool>,
pub operator: Vec<Operator>,
pub non_auto_renewable: Option<NonAutoRenewable>,
pub can_start_trial: Option<bool>,
pub mcdonalds: Option<bool>,
pub end: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct PassportPhone {
pub phone: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Account {
pub now: Option<String>,
pub service_available: Option<bool>,
pub region: Option<i64>,
pub uid: Option<i64>,
pub login: Option<String>,
pub full_name: Option<String>,
pub second_name: Option<String>,
pub first_name: Option<String>,
pub display_name: Option<String>,
pub hosted_user: Option<bool>,
pub birthday: Option<String>,
pub passport_phones: Vec<PassportPhone>,
pub registered_at: Option<String>,
pub has_info_for_app_metrica: Option<bool>,
pub child: Option<bool>,
pub region_code: Option<String>,
pub non_owner_family_member: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Status {
pub account: Option<Account>,
pub permissions: Option<Permissions>,
pub advertisement: Option<String>,
pub subscription: Option<Subscription>,
pub cache_limit: Option<i64>,
pub subeditor: Option<bool>,
pub subeditor_level: Option<i64>,
pub plus: Option<Plus>,
pub default_email: Option<String>,
pub skips_per_hour: Option<i64>,
pub station_exists: Option<bool>,
pub station_data: Option<Value>,
pub bar_below: Option<Value>,
pub premium_region: Option<i64>,
pub experiment: Option<i64>,
pub pretrial_active: Option<bool>,
pub userhash: Option<String>,
pub masterhub: Option<Value>,
pub has_options: Option<super::FlagOrList>,
}
impl Status {
#[must_use]
pub fn uid(&self) -> Option<i64> {
self.account.as_ref()?.uid
}
#[must_use]
pub fn has_plus(&self) -> bool {
self.plus.as_ref().and_then(|p| p.has_plus).unwrap_or(false)
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct UserSettings {
pub uid: Option<i64>,
pub last_fm_scrobbling_enabled: Option<bool>,
pub shuffle_enabled: Option<bool>,
pub volume_percents: Option<i64>,
pub modified: Option<String>,
pub facebook_scrobbling_enabled: Option<bool>,
pub add_new_track_on_playlist_top: Option<bool>,
pub user_music_visibility: Option<String>,
pub user_social_visibility: Option<String>,
pub rbt_disabled: Option<bool>,
pub theme: Option<String>,
pub promos_disabled: Option<bool>,
pub auto_play_radio: Option<bool>,
pub sync_queue_enabled: Option<bool>,
pub ads_disabled: Option<bool>,
pub disk_enabled: Option<bool>,
pub show_disk_tracks_in_library: Option<bool>,
pub explicit_forbidden: Option<bool>,
pub child_mod_enabled: Option<bool>,
pub wizard_is_passed: Option<bool>,
pub user_collection_hue: Option<String>,
pub child_mode_changed_by_user: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct Settings {
pub in_app_products: Option<Value>,
pub native_products: Option<Value>,
pub web_payment_url: Option<String>,
pub promo_codes_enabled: Option<bool>,
pub web_payment_month_product_price: Option<Value>,
pub offers_batch_id: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct PermissionAlerts {
pub alerts: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(default, rename_all = "camelCase")]
pub struct PromoCodeStatus {
pub status: Option<String>,
pub status_desc: Option<String>,
pub account_status: Option<Status>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub struct Experiments {
pub values: serde_json::Map<String, Value>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
#[serde(transparent)]
pub struct ExperimentsDetails {
pub values: serde_json::Map<String, Value>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn status_exposes_uid_and_plus() {
let status: Status =
serde_json::from_str(r#"{"account":{"uid":123,"login":"me"},"plus":{"hasPlus":true}}"#)
.unwrap();
assert_eq!(status.uid(), Some(123));
assert!(status.has_plus());
}
#[test]
fn a_status_without_plus_reports_false_rather_than_unknown() {
let empty: Status = serde_json::from_str("{}").unwrap();
assert!(!empty.has_plus());
assert_eq!(empty.uid(), None);
let no_plus: Status = serde_json::from_str(r#"{"plus":{"hasPlus":false}}"#).unwrap();
assert!(!no_plus.has_plus());
}
#[test]
fn free_form_blocks_are_kept_rather_than_dropped() {
let status: Status =
serde_json::from_str(r#"{"stationData":{"anything":[1,2]},"barBelow":"text"}"#)
.unwrap();
assert!(status.station_data.is_some());
assert!(status.bar_below.is_some());
}
#[test]
fn experiments_preserve_the_whole_map() {
let experiments: Experiments =
serde_json::from_str(r#"{"exp_a":"on","exp_b":"off"}"#).unwrap();
assert_eq!(experiments.values.len(), 2);
assert_eq!(experiments.values["exp_a"], Value::String("on".into()));
}
#[test]
fn subscription_blocks_deserialize_in_full() {
let subscription: Subscription = serde_json::from_str(
r#"{
"autoRenewable":[{"expires":"2027-01-01","product":{"productId":"p1","price":{"amount":299,"currency":"RUB"}}}],
"nonAutoRenewableRemainder":{"days":12},
"hadAnySubscription":true
}"#,
)
.unwrap();
assert_eq!(subscription.auto_renewable.len(), 1);
let product = subscription.auto_renewable[0].product.as_ref().unwrap();
assert_eq!(product.price.as_ref().unwrap().amount, Some(299.0));
assert_eq!(
subscription.non_auto_renewable_remainder.unwrap().days,
Some(12)
);
}
#[test]
fn every_account_model_survives_an_empty_object() {
serde_json::from_str::<Status>("{}").unwrap();
serde_json::from_str::<Account>("{}").unwrap();
serde_json::from_str::<UserSettings>("{}").unwrap();
serde_json::from_str::<Settings>("{}").unwrap();
serde_json::from_str::<Subscription>("{}").unwrap();
serde_json::from_str::<Product>("{}").unwrap();
serde_json::from_str::<PromoCodeStatus>("{}").unwrap();
serde_json::from_str::<PermissionAlerts>("{}").unwrap();
}
}