use std::fmt;
use crate::error::{Error, Result};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum RequestMethod {
#[default]
Get,
Post,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ContentType {
ForeignMovie,
SovietCartoon,
ForeignCartoon,
RussianCartoon,
Anime,
RussianMovie,
CartoonSerial,
DocumentarySerial,
RussianSerial,
ForeignSerial,
AnimeSerial,
MultiPartFilm,
}
impl ContentType {
pub const fn as_str(self) -> &'static str {
match self {
Self::ForeignMovie => "foreign-movie",
Self::SovietCartoon => "soviet-cartoon",
Self::ForeignCartoon => "foreign-cartoon",
Self::RussianCartoon => "russian-cartoon",
Self::Anime => "anime",
Self::RussianMovie => "russian-movie",
Self::CartoonSerial => "cartoon-serial",
Self::DocumentarySerial => "documentary-serial",
Self::RussianSerial => "russian-serial",
Self::ForeignSerial => "foreign-serial",
Self::AnimeSerial => "anime-serial",
Self::MultiPartFilm => "multi-part-film",
}
}
}
impl fmt::Display for ContentType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TranslationType {
Voice,
Subtitles,
}
impl TranslationType {
pub const fn as_str(self) -> &'static str {
match self {
Self::Voice => "voice",
Self::Subtitles => "subtitles",
}
}
}
impl fmt::Display for TranslationType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RequiredField {
KinopoiskId,
ImdbId,
MdlId,
WorldartLink,
ShikimoriId,
}
impl RequiredField {
pub const fn as_str(self) -> &'static str {
match self {
Self::KinopoiskId => "kinopoisk_id",
Self::ImdbId => "imdb_id",
Self::MdlId => "mdl_id",
Self::WorldartLink => "worldart_link",
Self::ShikimoriId => "shikimori_id",
}
}
}
impl fmt::Display for RequiredField {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum GenreSource {
#[default]
Kinopoisk,
Shikimori,
MyDramaList,
All,
}
impl GenreSource {
pub const fn as_str(self) -> &'static str {
match self {
Self::Kinopoisk => "kinopoisk",
Self::Shikimori => "shikimori",
Self::MyDramaList => "mydramalist",
Self::All => "all",
}
}
}
impl fmt::Display for GenreSource {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum SortOrder {
Asc,
#[default]
Desc,
}
impl SortOrder {
pub const fn as_str(self) -> &'static str {
match self {
Self::Asc => "asc",
Self::Desc => "desc",
}
}
}
impl fmt::Display for SortOrder {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ListSort {
Year,
CreatedAt,
#[default]
UpdatedAt,
KinopoiskRating,
ImdbRating,
ShikimoriRating,
}
impl ListSort {
pub const fn as_str(self) -> &'static str {
match self {
Self::Year => "year",
Self::CreatedAt => "created_at",
Self::UpdatedAt => "updated_at",
Self::KinopoiskRating => "kinopoisk_rating",
Self::ImdbRating => "imdb_rating",
Self::ShikimoriRating => "shikimori_rating",
}
}
}
impl fmt::Display for ListSort {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum LabelSort {
#[default]
Title,
Count,
}
impl LabelSort {
pub const fn as_str(self) -> &'static str {
match self {
Self::Title => "title",
Self::Count => "count",
}
}
}
impl fmt::Display for LabelSort {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum YearSort {
#[default]
Year,
Count,
}
impl YearSort {
pub const fn as_str(self) -> &'static str {
match self {
Self::Year => "year",
Self::Count => "count",
}
}
}
impl fmt::Display for YearSort {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Filters {
pub types: Vec<ContentType>,
pub year: Vec<i32>,
pub translation_ids: Vec<u64>,
pub block_translations: Vec<u64>,
pub translation_type: Option<TranslationType>,
pub has_field: Vec<RequiredField>,
pub has_field_and: Vec<RequiredField>,
pub camrip: Option<bool>,
pub lgbt: Option<bool>,
pub countries: Vec<String>,
pub countries_and: Vec<String>,
pub genres: Vec<String>,
pub genres_and: Vec<String>,
pub anime_genres: Vec<String>,
pub anime_genres_and: Vec<String>,
pub drama_genres: Vec<String>,
pub drama_genres_and: Vec<String>,
pub all_genres: Vec<String>,
pub all_genres_and: Vec<String>,
pub duration: Option<String>,
pub kinopoisk_rating: Option<String>,
pub imdb_rating: Option<String>,
pub shikimori_rating: Option<String>,
pub mydramalist_rating: Option<String>,
pub actors: Vec<String>,
pub actors_and: Vec<String>,
pub directors: Vec<String>,
pub directors_and: Vec<String>,
pub producers: Vec<String>,
pub producers_and: Vec<String>,
pub writers: Vec<String>,
pub writers_and: Vec<String>,
pub composers: Vec<String>,
pub composers_and: Vec<String>,
pub editors: Vec<String>,
pub editors_and: Vec<String>,
pub designers: Vec<String>,
pub designers_and: Vec<String>,
pub operators: Vec<String>,
pub operators_and: Vec<String>,
pub rating_mpaa: Vec<String>,
pub minimal_age: Option<String>,
pub anime_kind: Vec<String>,
pub mydramalist_tags: Vec<String>,
pub mydramalist_tags_and: Vec<String>,
pub anime_status: Vec<String>,
pub drama_status: Vec<String>,
pub all_status: Vec<String>,
pub anime_studios: Vec<String>,
pub anime_studios_and: Vec<String>,
pub anime_licensed_by: Vec<String>,
pub anime_licensed_by_and: Vec<String>,
}
impl Filters {
pub fn with_types(mut self, values: impl IntoIterator<Item = ContentType>) -> Self {
self.types.extend(values);
self
}
pub fn with_countries(mut self, values: impl IntoIterator<Item = impl Into<String>>) -> Self {
self.countries.extend(values.into_iter().map(Into::into));
self
}
pub fn with_genres(mut self, values: impl IntoIterator<Item = impl Into<String>>) -> Self {
self.genres.extend(values.into_iter().map(Into::into));
self
}
fn encode_into(&self, output: &mut Parameters) {
output.push_joined("types", &self.types);
output.push_joined("year", &self.year);
output.push_joined("translation_id", &self.translation_ids);
output.push_joined("block_translations", &self.block_translations);
output.push_option("translation_type", self.translation_type);
output.push_joined("has_field", &self.has_field);
output.push_joined("has_field_and", &self.has_field_and);
output.push_bool("camrip", self.camrip);
output.push_bool("lgbt", self.lgbt);
output.push_joined("countries", &self.countries);
output.push_joined("countries_and", &self.countries_and);
output.push_joined("genres", &self.genres);
output.push_joined("genres_and", &self.genres_and);
output.push_joined("anime_genres", &self.anime_genres);
output.push_joined("anime_genres_and", &self.anime_genres_and);
output.push_joined("drama_genres", &self.drama_genres);
output.push_joined("drama_genres_and", &self.drama_genres_and);
output.push_joined("all_genres", &self.all_genres);
output.push_joined("all_genres_and", &self.all_genres_and);
output.push_string("duration", self.duration.as_deref());
output.push_string("kinopoisk_rating", self.kinopoisk_rating.as_deref());
output.push_string("imdb_rating", self.imdb_rating.as_deref());
output.push_string("shikimori_rating", self.shikimori_rating.as_deref());
output.push_string("mydramalist_rating", self.mydramalist_rating.as_deref());
output.push_joined("actors", &self.actors);
output.push_joined("actors_and", &self.actors_and);
output.push_joined("directors", &self.directors);
output.push_joined("directors_and", &self.directors_and);
output.push_joined("producers", &self.producers);
output.push_joined("producers_and", &self.producers_and);
output.push_joined("writers", &self.writers);
output.push_joined("writers_and", &self.writers_and);
output.push_joined("composers", &self.composers);
output.push_joined("composers_and", &self.composers_and);
output.push_joined("editors", &self.editors);
output.push_joined("editors_and", &self.editors_and);
output.push_joined("designers", &self.designers);
output.push_joined("designers_and", &self.designers_and);
output.push_joined("operators", &self.operators);
output.push_joined("operators_and", &self.operators_and);
output.push_joined("rating_mpaa", &self.rating_mpaa);
output.push_string("minimal_age", self.minimal_age.as_deref());
output.push_joined("anime_kind", &self.anime_kind);
output.push_joined("mydramalist_tags", &self.mydramalist_tags);
output.push_joined("mydramalist_tags_and", &self.mydramalist_tags_and);
output.push_joined("anime_status", &self.anime_status);
output.push_joined("drama_status", &self.drama_status);
output.push_joined("all_status", &self.all_status);
output.push_joined("anime_studios", &self.anime_studios);
output.push_joined("anime_studios_and", &self.anime_studios_and);
output.push_joined("anime_licensed_by", &self.anime_licensed_by);
output.push_joined("anime_licensed_by_and", &self.anime_licensed_by_and);
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct YearsQuery {
pub filters: Filters,
pub sort: YearSort,
}
impl YearsQuery {
pub fn query_string(&self) -> String {
self.parameters().encoded()
}
fn parameters(&self) -> Parameters {
let mut parameters = Parameters::default();
self.filters.encode_into(&mut parameters);
parameters.push("sort", self.sort);
parameters
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct GenresQuery {
pub filters: Filters,
pub genres_type: GenreSource,
pub sort: LabelSort,
}
impl GenresQuery {
pub fn query_string(&self) -> String {
self.parameters().encoded()
}
fn parameters(&self) -> Parameters {
let mut parameters = Parameters::default();
self.filters.encode_into(&mut parameters);
parameters.push("genres_type", self.genres_type);
parameters.push("sort", self.sort);
parameters
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct CountriesQuery {
pub filters: Filters,
pub sort: LabelSort,
}
impl CountriesQuery {
pub fn query_string(&self) -> String {
self.parameters().encoded()
}
fn parameters(&self) -> Parameters {
let mut parameters = Parameters::default();
self.filters.encode_into(&mut parameters);
parameters.push("sort", self.sort);
parameters
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct QualitiesQuery {
pub filters: Filters,
pub sort: LabelSort,
}
impl QualitiesQuery {
pub fn query_string(&self) -> String {
self.parameters().encoded()
}
fn parameters(&self) -> Parameters {
let mut parameters = Parameters::default();
self.filters.encode_into(&mut parameters);
parameters.push("sort", self.sort);
parameters
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct TranslationsQuery {
pub filters: Filters,
pub sort: LabelSort,
}
impl TranslationsQuery {
pub fn query_string(&self) -> String {
self.parameters().encoded()
}
fn parameters(&self) -> Parameters {
let mut parameters = Parameters::default();
self.filters.encode_into(&mut parameters);
parameters.push("sort", self.sort);
parameters
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ListQuery {
pub filters: Filters,
pub limit: Option<u8>,
pub sort: ListSort,
pub order: SortOrder,
pub with_seasons: bool,
pub with_episodes: bool,
pub with_episodes_data: bool,
pub with_page_links: bool,
pub not_blocked_in: Vec<String>,
pub not_blocked_for_me: bool,
pub with_material_data: bool,
pub next: Option<String>,
}
impl ListQuery {
pub fn validate(&self) -> Result<()> {
if self.limit.is_some_and(|limit| !(1..=100).contains(&limit)) {
return Err(Error::Validation("list limit must be in 1..=100".into()));
}
Ok(())
}
pub fn query_string(&self) -> Result<String> {
Ok(self.parameters()?.encoded())
}
fn parameters(&self) -> Result<Parameters> {
self.validate()?;
let mut parameters = Parameters::default();
self.filters.encode_into(&mut parameters);
if let Some(limit) = self.limit {
parameters.push("limit", limit);
}
parameters.push("sort", self.sort);
parameters.push("order", self.order);
parameters.push_bool_if_true("with_seasons", self.with_seasons);
parameters.push_bool_if_true("with_episodes", self.with_episodes);
parameters.push_bool_if_true("with_episodes_data", self.with_episodes_data);
parameters.push_bool_if_true("with_page_links", self.with_page_links);
parameters.push_joined("not_blocked_in", &self.not_blocked_in);
parameters.push_bool_if_true("not_blocked_for_me", self.not_blocked_for_me);
parameters.push_bool_if_true("with_material_data", self.with_material_data);
parameters.push_string("next", self.next.as_deref());
Ok(parameters)
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct SearchQuery {
pub title: Option<String>,
pub title_orig: Option<String>,
pub strict: bool,
pub full_match: bool,
pub id: Option<String>,
pub player_link: Option<String>,
pub kinopoisk_ids: Vec<String>,
pub imdb_ids: Vec<String>,
pub mdl_ids: Vec<String>,
pub worldart_animation_ids: Vec<String>,
pub worldart_cinema_ids: Vec<String>,
pub worldart_link: Option<String>,
pub shikimori_ids: Vec<String>,
pub limit: Option<u8>,
pub filters: Filters,
pub prioritize_translations: Vec<String>,
pub unprioritize_translations: Vec<String>,
pub prioritize_translation_type: Option<TranslationType>,
pub with_seasons: bool,
pub season: Option<u32>,
pub with_episodes: bool,
pub with_episodes_data: bool,
pub episode: Option<u32>,
pub with_page_links: bool,
pub not_blocked_in: Vec<String>,
pub not_blocked_for_me: bool,
pub with_material_data: bool,
}
impl SearchQuery {
pub fn validate(&self) -> Result<()> {
if self.limit.is_some_and(|limit| !(1..=100).contains(&limit)) {
return Err(Error::Validation("search limit must be in 1..=100".into()));
}
if self.episode.is_some() && self.season.is_none() {
return Err(Error::Validation(
"search episode requires a corresponding season".into(),
));
}
if !has_text(self.title.as_deref())
&& !has_text(self.title_orig.as_deref())
&& !has_text(self.id.as_deref())
&& !has_text(self.player_link.as_deref())
&& !has_non_blank_item(&self.kinopoisk_ids)
&& !has_non_blank_item(&self.imdb_ids)
&& !has_non_blank_item(&self.mdl_ids)
&& !has_non_blank_item(&self.worldart_animation_ids)
&& !has_non_blank_item(&self.worldart_cinema_ids)
&& !has_text(self.worldart_link.as_deref())
&& !has_non_blank_item(&self.shikimori_ids)
{
return Err(Error::Validation(
"search requires title, title_orig, Kodik ID, player link, or an external ID"
.into(),
));
}
Ok(())
}
pub fn query_string(&self) -> Result<String> {
Ok(self.parameters()?.encoded())
}
fn parameters(&self) -> Result<Parameters> {
self.validate()?;
let mut parameters = Parameters::default();
parameters.push_string("title", self.title.as_deref());
parameters.push_string("title_orig", self.title_orig.as_deref());
parameters.push_bool_if_true("strict", self.strict);
parameters.push_bool_if_true("full_match", self.full_match);
parameters.push_string("id", self.id.as_deref());
parameters.push_string("player_link", self.player_link.as_deref());
parameters.push_joined("kinopoisk_id", &self.kinopoisk_ids);
parameters.push_joined("imdb_id", &self.imdb_ids);
parameters.push_joined("mdl_id", &self.mdl_ids);
parameters.push_joined("worldart_animation_id", &self.worldart_animation_ids);
parameters.push_joined("worldart_cinema_id", &self.worldart_cinema_ids);
parameters.push_string("worldart_link", self.worldart_link.as_deref());
parameters.push_joined("shikimori_id", &self.shikimori_ids);
if let Some(limit) = self.limit {
parameters.push("limit", limit);
}
self.filters.encode_into(&mut parameters);
parameters.push_joined("prioritize_translations", &self.prioritize_translations);
parameters.push_joined("unprioritize_translations", &self.unprioritize_translations);
parameters.push_option(
"prioritize_translation_type",
self.prioritize_translation_type,
);
parameters.push_bool_if_true("with_seasons", self.with_seasons);
if let Some(season) = self.season {
parameters.push("season", season);
}
parameters.push_bool_if_true("with_episodes", self.with_episodes);
parameters.push_bool_if_true("with_episodes_data", self.with_episodes_data);
if let Some(episode) = self.episode {
parameters.push("episode", episode);
}
parameters.push_bool_if_true("with_page_links", self.with_page_links);
parameters.push_joined("not_blocked_in", &self.not_blocked_in);
parameters.push_bool_if_true("not_blocked_for_me", self.not_blocked_for_me);
parameters.push_bool_if_true("with_material_data", self.with_material_data);
Ok(parameters)
}
}
#[derive(Clone, Debug, Default)]
pub(crate) struct Parameters(Vec<(String, String)>);
impl Parameters {
pub(crate) fn push(&mut self, key: impl Into<String>, value: impl fmt::Display) {
self.0.push((key.into(), value.to_string()));
}
fn push_string(&mut self, key: impl Into<String>, value: Option<&str>) {
if let Some(value) = value.filter(|value| !value.trim().is_empty()) {
self.0.push((key.into(), value.to_owned()));
}
}
fn push_option<T: fmt::Display>(&mut self, key: impl Into<String>, value: Option<T>) {
if let Some(value) = value {
self.push(key, value);
}
}
fn push_bool(&mut self, key: impl Into<String>, value: Option<bool>) {
if let Some(value) = value {
self.push(key, value);
}
}
fn push_bool_if_true(&mut self, key: impl Into<String>, value: bool) {
if value {
self.push(key, "true");
}
}
fn push_joined<T: fmt::Display>(&mut self, key: impl Into<String>, values: &[T]) {
if !values.is_empty() {
let value = values
.iter()
.map(ToString::to_string)
.collect::<Vec<_>>()
.join(",");
self.0.push((key.into(), value));
}
}
pub(crate) fn extend(&mut self, other: Parameters) {
self.0.extend(other.0);
}
pub(crate) fn encoded(&self) -> String {
self.0
.iter()
.map(|(key, value)| format!("{}={}", percent_encode(key), percent_encode(value)))
.collect::<Vec<_>>()
.join("&")
}
}
pub(crate) trait IntoParameters {
fn into_parameters(self) -> Result<Parameters>;
}
impl IntoParameters for YearsQuery {
fn into_parameters(self) -> Result<Parameters> {
Ok(self.parameters())
}
}
impl IntoParameters for GenresQuery {
fn into_parameters(self) -> Result<Parameters> {
Ok(self.parameters())
}
}
impl IntoParameters for CountriesQuery {
fn into_parameters(self) -> Result<Parameters> {
Ok(self.parameters())
}
}
impl IntoParameters for QualitiesQuery {
fn into_parameters(self) -> Result<Parameters> {
Ok(self.parameters())
}
}
impl IntoParameters for TranslationsQuery {
fn into_parameters(self) -> Result<Parameters> {
Ok(self.parameters())
}
}
impl IntoParameters for ListQuery {
fn into_parameters(self) -> Result<Parameters> {
self.parameters()
}
}
impl IntoParameters for SearchQuery {
fn into_parameters(self) -> Result<Parameters> {
self.parameters()
}
}
fn has_text(value: Option<&str>) -> bool {
value.is_some_and(|value| !value.trim().is_empty())
}
fn has_non_blank_item(values: &[String]) -> bool {
values.iter().any(|value| !value.trim().is_empty())
}
fn percent_encode(value: &str) -> String {
let mut encoded = String::with_capacity(value.len());
for byte in value.bytes() {
if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.' | b'~') {
encoded.push(byte as char);
} else {
encoded.push('%');
encoded.push(hex(byte >> 4));
encoded.push(hex(byte & 0x0f));
}
}
encoded
}
const fn hex(nibble: u8) -> char {
match nibble {
0..=9 => (b'0' + nibble) as char,
_ => (b'A' + nibble - 10) as char,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn encodes_unicode_and_comma_separated_values() {
let query = YearsQuery {
filters: Filters::default()
.with_types([ContentType::AnimeSerial])
.with_countries(["США", "Россия"]),
sort: YearSort::Count,
};
assert_eq!(
query.query_string(),
"types=anime-serial&countries=%D0%A1%D0%A8%D0%90%2C%D0%A0%D0%BE%D1%81%D1%81%D0%B8%D1%8F&sort=count"
);
}
#[test]
fn search_requires_a_criterion() {
let error = SearchQuery::default().validate().unwrap_err();
assert!(error.to_string().contains("search requires"));
}
#[test]
fn episode_requires_season() {
let query = SearchQuery {
title: Some("Test".into()),
episode: Some(4),
..Default::default()
};
assert!(query.validate().is_err());
}
#[test]
fn search_rejects_empty_or_whitespace_only_criteria() {
for value in ["", " ", "\n\t"] {
let query = SearchQuery {
title: Some(value.into()),
..Default::default()
};
assert!(
query.validate().is_err(),
"criterion {value:?} must be rejected"
);
}
let query = SearchQuery {
kinopoisk_ids: vec![" ".into(), "\t".into()],
..Default::default()
};
assert!(query.validate().is_err());
}
#[test]
fn list_and_search_reject_limits_outside_one_through_one_hundred() {
for limit in [0, 101] {
assert!(ListQuery {
limit: Some(limit),
..Default::default()
}
.validate()
.is_err());
assert!(SearchQuery {
title: Some("Avatar".into()),
limit: Some(limit),
..Default::default()
}
.validate()
.is_err());
}
}
}