use crate::models::{
Links, album::Album, artist::Artist, artist_biography::ArtistBiography,
artist_role::ArtistRole, artwork::Artwork, genre::Genre, lyrics::Lyrics, playlist::Playlist,
provider::Provider, search_result::SearchResult, search_suggestions::SearchSuggestion,
track::Track, track_file::TrackFile, track_manifest::TrackManifest,
track_statistics::TrackStatistics, user::User, user_collection::UserCollection,
user_recommendation::UserRecommendation, user_share::UserShare, video::Video,
};
use serde::{Deserialize, Deserializer, Serialize, Serializer, de::DeserializeOwned};
use serde_json::Value;
use strum::{AsRefStr, Display, IntoStaticStr};
#[derive(
Clone,
Copy,
Debug,
Eq,
PartialEq,
Ord,
PartialOrd,
Hash,
Serialize,
Deserialize,
Display,
AsRefStr,
IntoStaticStr,
)]
#[serde(rename_all = "camelCase")]
#[strum(serialize_all = "camelCase")]
pub enum ResourceType {
Albums,
Appreciations,
ArtistBiographies,
ArtistRoles,
Artists,
Artworks,
Genres,
Lyrics,
Playlists,
Providers,
SearchResults,
SearchSuggestions,
TrackFiles,
TrackManifests,
TrackSourceFiles,
TrackStatistics,
Tracks,
UserCollections,
UserEntitlements,
UserRecommendations,
UserShares,
Users,
Videos,
}
#[derive(Clone, Debug, PartialEq)]
pub enum AnyResource {
Albums(Album),
Appreciations(Value),
ArtistBiographies(ArtistBiography),
ArtistRoles(ArtistRole),
Artists(Artist),
Artworks(Artwork),
Genres(Genre),
Lyrics(Lyrics),
Playlists(Playlist),
Providers(Provider),
SearchResults(SearchResult),
SearchSuggestions(SearchSuggestion),
TrackFiles(TrackFile),
TrackManifests(TrackManifest),
TrackSourceFiles(Value),
TrackStatistics(TrackStatistics),
Tracks(Track),
UserCollections(UserCollection),
UserEntitlements(Value),
UserRecommendations(UserRecommendation),
UserShares(UserShare),
Users(User),
Videos(Video),
}
impl AnyResource {
pub fn resource_type(&self) -> ResourceType {
match self {
AnyResource::Albums(_) => ResourceType::Albums,
AnyResource::Appreciations(_) => ResourceType::Appreciations,
AnyResource::ArtistBiographies(_) => ResourceType::ArtistBiographies,
AnyResource::ArtistRoles(_) => ResourceType::ArtistRoles,
AnyResource::Artists(_) => ResourceType::Artists,
AnyResource::Artworks(_) => ResourceType::Artworks,
AnyResource::Genres(_) => ResourceType::Genres,
AnyResource::Lyrics(_) => ResourceType::Lyrics,
AnyResource::Playlists(_) => ResourceType::Playlists,
AnyResource::Providers(_) => ResourceType::Providers,
AnyResource::SearchResults(_) => ResourceType::SearchResults,
AnyResource::SearchSuggestions(_) => ResourceType::SearchSuggestions,
AnyResource::TrackFiles(_) => ResourceType::TrackFiles,
AnyResource::TrackManifests(_) => ResourceType::TrackManifests,
AnyResource::TrackSourceFiles(_) => ResourceType::TrackSourceFiles,
AnyResource::TrackStatistics(_) => ResourceType::TrackStatistics,
AnyResource::Tracks(_) => ResourceType::Tracks,
AnyResource::UserCollections(_) => ResourceType::UserCollections,
AnyResource::UserEntitlements(_) => ResourceType::UserEntitlements,
AnyResource::UserRecommendations(_) => ResourceType::UserRecommendations,
AnyResource::UserShares(_) => ResourceType::UserShares,
AnyResource::Users(_) => ResourceType::Users,
AnyResource::Videos(_) => ResourceType::Videos,
}
}
}
impl From<AnyResource> for ResourceType {
fn from(val: AnyResource) -> Self {
val.resource_type()
}
}
impl Default for AnyResource {
fn default() -> Self {
Self::Albums(Default::default())
}
}
impl<'de> Deserialize<'de> for AnyResource {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let v = serde_json::Value::deserialize(deserializer)?;
let type_str = v
.get("type")
.and_then(|t| t.as_str())
.ok_or_else(|| serde::de::Error::custom("missing or non-string `type` field"))?;
fn from_value<T: for<'a> Deserialize<'a>, E: serde::de::Error>(
v: serde_json::Value,
) -> Result<T, E> {
serde_json::from_value(v).map_err(E::custom)
}
match type_str {
"albums" => Ok(AnyResource::Albums(from_value(v)?)),
"appreciations" => Ok(AnyResource::Appreciations(from_value(v)?)),
"artistBiographies" => Ok(AnyResource::ArtistBiographies(from_value(v)?)),
"artistRoles" => Ok(AnyResource::ArtistRoles(from_value(v)?)),
"artists" => Ok(AnyResource::Artists(from_value(v)?)),
"artworks" => Ok(AnyResource::Artworks(from_value(v)?)),
"genres" => Ok(AnyResource::Genres(from_value(v)?)),
"lyrics" => Ok(AnyResource::Lyrics(from_value(v)?)),
"playlists" => Ok(AnyResource::Playlists(from_value(v)?)),
"providers" => Ok(AnyResource::Providers(from_value(v)?)),
"searchResults" => Ok(AnyResource::SearchResults(from_value(v)?)),
"searchSuggestions" => Ok(AnyResource::SearchSuggestions(from_value(v)?)),
"trackFiles" => Ok(AnyResource::TrackFiles(from_value(v)?)),
"trackManifests" => Ok(AnyResource::TrackManifests(from_value(v)?)),
"trackSourceFiles" => Ok(AnyResource::TrackSourceFiles(from_value(v)?)),
"trackStatistics" => Ok(AnyResource::TrackStatistics(from_value(v)?)),
"tracks" => Ok(AnyResource::Tracks(from_value(v)?)),
"userCollections" => Ok(AnyResource::UserCollections(from_value(v)?)),
"userEntitlements" => Ok(AnyResource::UserEntitlements(from_value(v)?)),
"userRecommendations" => Ok(AnyResource::UserRecommendations(from_value(v)?)),
"userShares" => Ok(AnyResource::UserShares(from_value(v)?)),
"users" => Ok(AnyResource::Users(from_value(v)?)),
"videos" => Ok(AnyResource::Videos(from_value(v)?)),
other => Err(serde::de::Error::custom(format!(
"unknown `type` discriminator: {other}"
))),
}
}
}
impl Serialize for AnyResource {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
AnyResource::Albums(v) => v.serialize(serializer),
AnyResource::Appreciations(v) => v.serialize(serializer),
AnyResource::ArtistBiographies(v) => v.serialize(serializer),
AnyResource::ArtistRoles(v) => v.serialize(serializer),
AnyResource::Artists(v) => v.serialize(serializer),
AnyResource::Artworks(v) => v.serialize(serializer),
AnyResource::Genres(v) => v.serialize(serializer),
AnyResource::Lyrics(v) => v.serialize(serializer),
AnyResource::Playlists(v) => v.serialize(serializer),
AnyResource::Providers(v) => v.serialize(serializer),
AnyResource::SearchResults(v) => v.serialize(serializer),
AnyResource::SearchSuggestions(v) => v.serialize(serializer),
AnyResource::TrackFiles(v) => v.serialize(serializer),
AnyResource::TrackManifests(v) => v.serialize(serializer),
AnyResource::TrackSourceFiles(v) => v.serialize(serializer),
AnyResource::TrackStatistics(v) => v.serialize(serializer),
AnyResource::Tracks(v) => v.serialize(serializer),
AnyResource::UserCollections(v) => v.serialize(serializer),
AnyResource::UserEntitlements(v) => v.serialize(serializer),
AnyResource::UserRecommendations(v) => v.serialize(serializer),
AnyResource::UserShares(v) => v.serialize(serializer),
AnyResource::Users(v) => v.serialize(serializer),
AnyResource::Videos(v) => v.serialize(serializer),
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct Resource<T> {
#[serde(rename = "data")]
pub data: T,
#[serde(rename = "included", skip_serializing_if = "Vec::is_empty", default)]
pub included: Vec<AnyResource>,
#[serde(rename = "links")]
pub links: Links,
}
impl<T> Resource<T> {
pub fn new(data: T, links: Links) -> Resource<T> {
Resource {
data,
included: Vec::new(),
links,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct MultiResource<T> {
#[serde(rename = "data")]
pub data: Vec<T>,
#[serde(rename = "included", skip_serializing_if = "Vec::is_empty", default)]
pub included: Vec<AnyResource>,
#[serde(rename = "links")]
pub links: Links,
}
impl<T> MultiResource<T> {
pub fn new(data: Vec<T>, links: Links) -> MultiResource<T> {
MultiResource {
data,
included: Vec::new(),
links,
}
}
pub fn into_singleton(self) -> Result<Resource<T>, crate::error::Error> {
let actual = self.data.len();
let mut data = self.data;
match data.pop() {
Some(item) if data.is_empty() => Ok(Resource {
data: item,
included: self.included,
links: self.links,
}),
_ => Err(crate::error::Error::UnexpectedCollectionSize {
expected: 1,
actual,
}),
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct Relationship {
#[serde(rename = "data", skip_serializing_if = "Option::is_none")]
pub data: Option<ResourceIdentifier>,
#[serde(rename = "included", skip_serializing_if = "Vec::is_empty", default)]
pub included: Vec<AnyResource>,
#[serde(rename = "links")]
pub links: Links,
}
impl Relationship {
pub fn new(links: Links) -> Relationship {
Relationship {
data: None,
included: Vec::new(),
links,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct MultiRelationship<T> {
#[serde(rename = "data", skip_serializing_if = "Option::is_none")]
pub data: Option<Vec<T>>,
#[serde(rename = "included", skip_serializing_if = "Vec::is_empty", default)]
pub included: Vec<AnyResource>,
#[serde(rename = "links")]
pub links: Links,
}
impl<T> MultiRelationship<T> {
pub fn new(links: Links) -> MultiRelationship<T> {
MultiRelationship {
data: None,
included: Vec::new(),
links,
}
}
}
#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataWrap<T, M = ()> {
pub data: T,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub meta: Option<M>,
}
impl<T> DataWrap<T, ()> {
pub fn new(data: T) -> Self {
Self { data, meta: None }
}
}
impl<T, M> DataWrap<T, M> {
pub fn new_with_meta(data: T, meta: M) -> Self {
Self {
data,
meta: Some(meta),
}
}
}
impl<T> From<T> for DataWrap<T, ()> {
fn from(data: T) -> Self {
DataWrap::new(data)
}
}
impl<T, M> From<(T, M)> for DataWrap<T, M> {
fn from((data, meta): (T, M)) -> Self {
DataWrap::new_with_meta(data, meta)
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ResourceIdentifier<M = ()> {
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "type")]
pub r#type: ResourceType,
#[serde(rename = "meta", skip_serializing_if = "Option::is_none")]
pub meta: Option<M>,
}
impl ResourceIdentifier<()> {
pub fn new(id: String, r#type: ResourceType) -> ResourceIdentifier {
ResourceIdentifier {
id,
r#type,
meta: None,
}
}
}
impl<M> ResourceIdentifier<M> {
pub fn new_with_meta(id: String, r#type: ResourceType, meta: M) -> ResourceIdentifier<M> {
ResourceIdentifier {
id,
r#type,
meta: Some(meta),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error::Error;
fn collection(items: Vec<u32>) -> MultiResource<u32> {
MultiResource::new(items, Links::new("/searchResults".to_string()))
}
#[test]
fn into_singleton_unwraps_one_item() {
let resource = collection(vec![7]).into_singleton().expect("singleton");
assert_eq!(resource.data, 7);
assert_eq!(resource.links.param_self, "/searchResults");
assert!(resource.included.is_empty());
}
#[test]
fn into_singleton_rejects_empty() {
let err = collection(vec![]).into_singleton().unwrap_err();
assert!(matches!(
err,
Error::UnexpectedCollectionSize {
expected: 1,
actual: 0
}
));
}
#[test]
fn into_singleton_rejects_multiple() {
let err = collection(vec![1, 2]).into_singleton().unwrap_err();
assert!(matches!(
err,
Error::UnexpectedCollectionSize {
expected: 1,
actual: 2
}
));
}
}