use serde::{Serialize, Deserialize};
use serde::de::Error;
#[derive(Deserialize, Serialize, Debug)]
pub struct VnLinks {
pub wikidata: Option<String>,
pub renai: Option<String>
}
#[derive(Deserialize, Serialize, Debug)]
pub struct VnAnime {
pub id: u64,
pub ann_id: Option<u64>,
pub nfo_id: Option<u64>,
pub title_romaji: Option<String>,
pub title_kanji: Option<String>,
pub year: Option<u16>,
#[serde(rename = "type")]
pub kind: Option<String>
}
#[derive(Deserialize, Serialize, Debug)]
pub struct VnRelation {
pub id: u64,
pub relation: String,
pub title: String,
pub original: Option<String>,
pub official: bool
}
#[derive(Deserialize, Serialize, Debug)]
pub struct VnTag {
pub id: u64,
pub score: f32,
#[serde(rename = "spoiler level")]
pub spoiler: u8
}
#[derive(Deserialize, Serialize, Debug)]
pub struct VnScreen {
pub image: String,
pub rid: u64,
pub flagging: Option<VnImageFlags>,
pub height: u16,
pub width: u16,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct VnStaff {
#[serde(rename = "sid")]
pub id: u64,
#[serde(rename = "aid")]
pub alias: u64,
pub name: String,
pub original: Option<String>,
pub role: String,
pub note: Option<String>
}
#[derive(Deserialize, Serialize, Debug)]
pub struct VnImageFlags {
#[serde(rename = "votecount")]
pub vote_count: usize,
pub sexual_avg: Option<f32>,
pub violence_avg: Option<f32>,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct Vn {
pub id: u64,
pub title: Option<String>,
pub original: Option<String>,
pub released: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub languages: Vec<String>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub orig_lang: Vec<String>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub platforms: Vec<String>,
pub aliases: Option<String>,
pub length: Option<u8>,
pub description: Option<String>,
pub links: Option<VnLinks>,
pub image: Option<String>,
pub image_flagging: Option<VnImageFlags>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub anime: Vec<VnAnime>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub relations: Vec<VnRelation>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub tags: Vec<VnTag>,
#[serde(default)]
pub popularity: f32,
pub rating: Option<f32>,
pub votecount: Option<u64>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub screens: Vec<VnScreen>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub staff: Vec<VnStaff>,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct ReleaseMedia {
pub medium: String,
#[serde(rename = "qty")]
pub quantity: Option<u32>
}
#[derive(Deserialize, Serialize, Debug)]
pub struct ReleaseVN {
pub id: u64,
pub title: String,
pub original: Option<String>
}
#[derive(Deserialize, Serialize, Debug)]
pub struct ReleaseProducer {
pub id: u64,
pub developer: bool,
pub publisher: bool,
pub name: String,
pub original: Option<String>,
#[serde(rename = "type")]
pub kind: String,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct Release {
pub id: u64,
pub title: Option<String>,
pub original: Option<String>,
pub released: Option<String>,
#[serde(rename = "type")]
pub kind: Option<String>,
pub patch: Option<bool>,
pub freeware: Option<bool>,
pub doujin: Option<bool>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub languages: Vec<String>,
pub website: Option<String>,
pub notes: Option<String>,
#[serde(rename = "minage")]
pub age: Option<u8>,
#[serde(rename = "gtin")]
pub code: Option<String>,
pub catalog: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub platforms: Vec<String>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub media: Vec<ReleaseMedia>,
pub resolution: Option<String>,
pub voiced: Option<u8>,
pub animation: Option<[u8; 2]>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub vn: Vec<ReleaseVN>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub producers: Vec<ReleaseProducer>,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct ProducerLinks {
pub homepage: Option<String>,
pub wikidata: Option<String>
}
#[derive(Deserialize, Serialize, Debug)]
pub struct ProducerRelation {
pub id: u64,
pub relation: String,
pub name: String,
pub original: Option<String>
}
#[derive(Deserialize, Serialize, Debug)]
pub struct Producer {
pub id: u64,
pub name: Option<String>,
pub original: Option<String>,
#[serde(rename = "type")]
pub kind: Option<String>,
pub language: Option<String>,
pub links: Option<ProducerLinks>,
pub aliases: Option<String>,
pub description: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub relations: Vec<ProducerRelation>,
}
#[derive(Debug)]
pub enum CharacterGender {
Male,
Female,
Both
}
impl<'de> Deserialize<'de> for CharacterGender {
fn deserialize<D: serde::de::Deserializer<'de>>(gender: D) -> Result<Self, D::Error> {
let gender: &'de str = Deserialize::deserialize(gender)?;
match gender {
"m" => Ok(CharacterGender::Male),
"f" => Ok(CharacterGender::Female),
"b" => Ok(CharacterGender::Both),
_ => Err(D::Error::custom(format_args!("Unknown type '{}' of character gender.", gender)))
}
}
}
impl Serialize for CharacterGender {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match *self {
CharacterGender::Male => serializer.serialize_str("m"),
CharacterGender::Female => serializer.serialize_str("f"),
CharacterGender::Both => serializer.serialize_str("b")
}
}
}
#[derive(Deserialize, Serialize, Debug)]
pub struct CharacterSeiyuu {
pub id: u64,
pub aid: u64,
pub vid: u64,
pub note: String,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct Character {
pub id: u64,
pub name: Option<String>,
pub original: Option<String>,
pub gender: Option<CharacterGender>,
#[serde(rename = "bloodt")]
pub blood_type: Option<String>,
pub birthday: Option<(u8, u8)>,
pub aliases: Option<String>,
pub description: Option<String>,
pub image: Option<String>,
pub bust: Option<u16>,
pub waist: Option<u16>,
pub hip: Option<u16>,
pub height: Option<u16>,
pub weight: Option<u16>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub traits: Vec<(u64, u8)>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub vns: Vec<(u64, u64, u8, String)>,
#[serde(skip_serializing_if = "Vec::is_empty", default)]
pub voiced: Vec<CharacterSeiyuu>,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct User {
pub id: Option<u64>,
#[serde(rename = "username")]
pub name: Option<String>,
}
#[derive(Deserialize, Serialize, Debug)]
pub struct VoteList {
pub uid: Option<u64>,
pub vn: Option<u64>,
pub vote: Option<u8>,
pub added: Option<u64>,
}
#[derive(Copy, Clone, Debug)]
pub enum VnStatus {
Unknown = 0,
Playing = 1,
Finished = 2,
Stalled = 3,
Dropped = 4
}
impl<'de> Deserialize<'de> for VnStatus {
fn deserialize<D: serde::de::Deserializer<'de>>(status: D) -> Result<Self, D::Error> {
let status: u8 = Deserialize::deserialize(status)?;
match status {
0 => Ok(VnStatus::Unknown),
1 => Ok(VnStatus::Playing),
2 => Ok(VnStatus::Finished),
3 => Ok(VnStatus::Stalled),
4 => Ok(VnStatus::Dropped),
_ => Err(D::Error::custom(format_args!("Unknown type '{}' of VN's status.", status)))
}
}
}
impl Serialize for VnStatus {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_u8(*self as u8)
}
}
#[derive(Deserialize, Serialize, Debug)]
pub struct VnList {
pub uid: Option<u64>,
pub vn: Option<u64>,
pub status: Option<VnStatus>,
#[serde(default)]
pub added: u64,
pub notes: Option<String>
}
#[derive(Deserialize, Serialize, Debug)]
pub struct UList {
pub uid: Option<u64>,
pub vn: Option<u64>,
#[serde(default)]
pub added: u64,
#[serde(rename = "lastmod", default)]
pub last_mod: u64,
#[serde(default)]
pub voted: u64,
pub vote: Option<u8>,
pub notes: Option<String>
}