1use serde::Serialize;
4
5pub trait QueryParameters {
7 fn append_to(&self, output: &mut Vec<(String, String)>);
9
10 fn pairs(&self) -> Vec<(String, String)> {
12 let mut output = Vec::new();
13 self.append_to(&mut output);
14 output
15 }
16}
17
18impl QueryParameters for () {
19 fn append_to(&self, _: &mut Vec<(String, String)>) {}
20}
21
22fn optional<T: ToString>(output: &mut Vec<(String, String)>, key: &str, value: &Option<T>) {
23 if let Some(value) = value {
24 output.push((key.to_owned(), value.to_string()));
25 }
26}
27
28fn optional_bool(output: &mut Vec<(String, String)>, key: &str, value: Option<bool>) {
29 if let Some(value) = value {
30 output.push((key.to_owned(), value.to_string()));
31 }
32}
33
34fn optional_csv<T: ToString>(
35 output: &mut Vec<(String, String)>,
36 key: &str,
37 value: &Option<Vec<T>>,
38) {
39 if let Some(value) = value {
40 output.push((
41 key.to_owned(),
42 value
43 .iter()
44 .map(ToString::to_string)
45 .collect::<Vec<_>>()
46 .join(","),
47 ));
48 }
49}
50
51#[derive(Debug, Clone, Default, PartialEq, Eq)]
53pub struct PageLimitQuery {
54 pub page: Option<u64>,
56 pub limit: Option<u64>,
58}
59
60impl QueryParameters for PageLimitQuery {
61 fn append_to(&self, output: &mut Vec<(String, String)>) {
62 optional(output, "page", &self.page);
63 optional(output, "limit", &self.limit);
64 }
65}
66
67#[derive(Debug, Clone, Copy, PartialEq, Eq)]
69pub struct AchievementsQuery {
70 pub user_id: u64,
72}
73impl QueryParameters for AchievementsQuery {
74 fn append_to(&self, o: &mut Vec<(String, String)>) {
75 o.push(("user_id".into(), self.user_id.to_string()));
76 }
77}
78
79#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
81pub struct CensoredQuery {
82 pub censored: Option<bool>,
84}
85impl QueryParameters for CensoredQuery {
86 fn append_to(&self, o: &mut Vec<(String, String)>) {
87 optional_bool(o, "censored", self.censored);
88 }
89}
90
91#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
93pub struct LimitQuery {
94 pub limit: Option<u64>,
96}
97impl QueryParameters for LimitQuery {
98 fn append_to(&self, o: &mut Vec<(String, String)>) {
99 optional(o, "limit", &self.limit);
100 }
101}
102
103#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
105pub struct IsNicknameQuery {
106 pub is_nickname: bool,
108}
109impl QueryParameters for IsNicknameQuery {
110 fn append_to(&self, o: &mut Vec<(String, String)>) {
111 if self.is_nickname {
112 o.push(("is_nickname".into(), "1".into()));
113 }
114 }
115}
116
117#[derive(Debug, Clone, Default, PartialEq, Eq)]
119pub struct SearchQuery {
120 pub search: Option<String>,
122 pub kind: Option<PersonKind>,
124}
125impl QueryParameters for SearchQuery {
126 fn append_to(&self, o: &mut Vec<(String, String)>) {
127 optional(o, "search", &self.search);
128 optional(o, "kind", &self.kind);
129 }
130}
131
132#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize)]
134pub struct ReorderFavoriteRequest {
135 #[serde(skip_serializing_if = "Option::is_none")]
136 pub new_index: Option<u64>,
138}
139
140#[derive(Debug, Clone, Copy, PartialEq, Eq)]
142pub enum UserRateListType {
143 Anime,
145 Manga,
147}
148impl ::std::fmt::Display for UserRateListType {
149 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
150 f.write_str(match self {
151 Self::Anime => "anime",
152 Self::Manga => "manga",
153 })
154 }
155}
156
157#[derive(Debug, Clone, Default, PartialEq)]
159pub struct ListAnimesQuery {
160 pub page: Option<u64>,
162 pub limit: Option<u64>,
164 pub order: Option<AnimeOrder>,
166 pub legacy_type: Option<String>,
168 pub kind: Option<Vec<ListValue<AnimeKind>>>,
170 pub status: Option<Vec<ListValue<AnimeStatus>>>,
172 pub season: Option<Vec<String>>,
174 pub score: Option<f64>,
176 pub duration: Option<AnimeDuration>,
178 pub rating: Option<AgeRating>,
180 pub genre: Option<Vec<u64>>,
182 pub genre_v2: Option<Vec<u64>>,
184 pub studio: Option<Vec<u64>>,
186 pub franchise: Option<Vec<String>>,
188 pub censored: Option<bool>,
190 pub mylist: Option<UserRateStatus>,
192 pub ids: Option<Vec<u64>>,
194 pub exclude_ids: Option<Vec<u64>>,
196 pub search: Option<String>,
198}
199
200impl QueryParameters for ListAnimesQuery {
201 fn append_to(&self, output: &mut Vec<(String, String)>) {
202 optional(output, "page", &self.page);
203 optional(output, "limit", &self.limit);
204 optional(output, "order", &self.order);
205 optional(output, "type", &self.legacy_type);
206 optional_csv(output, "kind", &self.kind);
207 optional_csv(output, "status", &self.status);
208 optional_csv(output, "season", &self.season);
209 optional(output, "score", &self.score);
210 optional(output, "duration", &self.duration);
211 optional(output, "rating", &self.rating);
212 optional_csv(output, "genre", &self.genre);
213 optional_csv(output, "genre_v2", &self.genre_v2);
214 optional_csv(output, "studio", &self.studio);
215 optional_csv(output, "franchise", &self.franchise);
216 optional_bool(output, "censored", self.censored);
217 optional(output, "mylist", &self.mylist);
218 optional_csv(output, "ids", &self.ids);
219 optional_csv(output, "exclude_ids", &self.exclude_ids);
220 optional(output, "search", &self.search);
221 }
222}
223
224#[derive(Debug, Clone, Default, PartialEq)]
226pub struct ListMangasQuery {
227 pub page: Option<u64>,
229 pub limit: Option<u64>,
231 pub order: Option<MangaOrder>,
233 pub legacy_type: Option<String>,
235 pub kind: Option<Vec<ListValue<MangaKind>>>,
237 pub status: Option<Vec<ListValue<MangaStatus>>>,
239 pub season: Option<Vec<String>>,
241 pub score: Option<f64>,
243 pub genre: Option<Vec<u64>>,
245 pub genre_v2: Option<Vec<u64>>,
247 pub publisher: Option<Vec<u64>>,
249 pub franchise: Option<Vec<String>>,
251 pub censored: Option<bool>,
253 pub mylist: Option<UserRateStatus>,
255 pub ids: Option<Vec<u64>>,
257 pub exclude_ids: Option<Vec<u64>>,
259 pub search: Option<String>,
261}
262
263impl QueryParameters for ListMangasQuery {
264 fn append_to(&self, output: &mut Vec<(String, String)>) {
265 optional(output, "page", &self.page);
266 optional(output, "limit", &self.limit);
267 optional(output, "order", &self.order);
268 optional(output, "type", &self.legacy_type);
269 optional_csv(output, "kind", &self.kind);
270 optional_csv(output, "status", &self.status);
271 optional_csv(output, "season", &self.season);
272 optional(output, "score", &self.score);
273 optional_csv(output, "genre", &self.genre);
274 optional_csv(output, "genre_v2", &self.genre_v2);
275 optional_csv(output, "publisher", &self.publisher);
276 optional_csv(output, "franchise", &self.franchise);
277 optional_bool(output, "censored", self.censored);
278 optional(output, "mylist", &self.mylist);
279 optional_csv(output, "ids", &self.ids);
280 optional_csv(output, "exclude_ids", &self.exclude_ids);
281 optional(output, "search", &self.search);
282 }
283}
284
285#[derive(Debug, Clone, Default, PartialEq)]
287pub struct ListRanobeQuery {
288 pub page: Option<u64>,
290 pub limit: Option<u64>,
292 pub order: Option<MangaOrder>,
294 pub status: Option<Vec<ListValue<MangaStatus>>>,
296 pub season: Option<Vec<String>>,
298 pub score: Option<f64>,
300 pub genre: Option<Vec<u64>>,
302 pub publisher: Option<Vec<u64>>,
304 pub franchise: Option<Vec<String>>,
306 pub censored: Option<bool>,
308 pub mylist: Option<UserRateStatus>,
310 pub ids: Option<Vec<u64>>,
312 pub exclude_ids: Option<Vec<u64>>,
314 pub search: Option<String>,
316}
317
318impl QueryParameters for ListRanobeQuery {
319 fn append_to(&self, output: &mut Vec<(String, String)>) {
320 optional(output, "page", &self.page);
321 optional(output, "limit", &self.limit);
322 optional(output, "order", &self.order);
323 optional_csv(output, "status", &self.status);
324 optional_csv(output, "season", &self.season);
325 optional(output, "score", &self.score);
326 optional_csv(output, "genre", &self.genre);
327 optional_csv(output, "publisher", &self.publisher);
328 optional_csv(output, "franchise", &self.franchise);
329 optional_bool(output, "censored", self.censored);
330 optional(output, "mylist", &self.mylist);
331 optional_csv(output, "ids", &self.ids);
332 optional_csv(output, "exclude_ids", &self.exclude_ids);
333 optional(output, "search", &self.search);
334 }
335}
336
337#[derive(Debug, Clone, Default, PartialEq, Eq)]
339pub struct ListClubsQuery {
340 pub page: Option<u64>,
342 pub limit: Option<u64>,
344 pub search: Option<String>,
346}
347impl QueryParameters for ListClubsQuery {
348 fn append_to(&self, o: &mut Vec<(String, String)>) {
349 optional(o, "page", &self.page);
350 optional(o, "limit", &self.limit);
351 optional(o, "search", &self.search);
352 }
353}
354
355#[derive(Debug, Clone, Default, PartialEq, Eq)]
357pub struct PageLimit30Query {
358 pub page: Option<u64>,
360 pub limit: Option<u64>,
362}
363impl QueryParameters for PageLimit30Query {
364 fn append_to(&self, o: &mut Vec<(String, String)>) {
365 optional(o, "page", &self.page);
366 optional(o, "limit", &self.limit);
367 }
368}
369
370#[derive(Debug, Clone, PartialEq, Eq)]
372pub struct ListCommentsQuery {
373 pub commentable_id: u64,
375 pub commentable_type: CommentListTarget,
377 pub page: Option<u64>,
379 pub limit: Option<u64>,
381 pub desc: Option<bool>,
383}
384impl QueryParameters for ListCommentsQuery {
385 fn append_to(&self, o: &mut Vec<(String, String)>) {
386 o.push(("commentable_id".into(), self.commentable_id.to_string()));
387 o.push(("commentable_type".into(), self.commentable_type.to_string()));
388 optional(o, "page", &self.page);
389 optional(o, "limit", &self.limit);
390 optional_bool(o, "desc", self.desc);
391 }
392}
393
394#[derive(Debug, Clone, Default, PartialEq, Eq)]
396pub struct ListTopicsQuery {
397 pub page: Option<u64>,
399 pub limit: Option<u64>,
401 pub forum: Option<TopicForum>,
403 pub linked_id: Option<u64>,
405 pub linked_type: Option<TopicLinkedType>,
407 pub topic_type: Option<TopicType>,
409}
410impl QueryParameters for ListTopicsQuery {
411 fn append_to(&self, o: &mut Vec<(String, String)>) {
412 optional(o, "page", &self.page);
413 optional(o, "limit", &self.limit);
414 optional(o, "forum", &self.forum);
415 optional(o, "linked_id", &self.linked_id);
416 optional(o, "linked_type", &self.linked_type);
417 optional(o, "type", &self.topic_type);
418 }
419}
420
421#[derive(Debug, Clone, Default, PartialEq, Eq)]
423pub struct ListUsersQuery {
424 pub page: Option<u64>,
426 pub limit: Option<u64>,
428 pub search: Option<String>,
430}
431impl QueryParameters for ListUsersQuery {
432 fn append_to(&self, o: &mut Vec<(String, String)>) {
433 optional(o, "page", &self.page);
434 optional(o, "limit", &self.limit);
435 optional(o, "search", &self.search);
436 }
437}
438
439#[derive(Debug, Clone, Default, PartialEq, Eq)]
441pub struct ListUserRatesV2Query {
442 pub user_id: Option<u64>,
444 pub target_id: Option<u64>,
446 pub target_type: Option<RateTargetType>,
448 pub status: Option<UserRateStatus>,
450 pub page: Option<u64>,
452 pub limit: Option<u64>,
454}
455impl QueryParameters for ListUserRatesV2Query {
456 fn append_to(&self, o: &mut Vec<(String, String)>) {
457 optional(o, "user_id", &self.user_id);
458 optional(o, "target_id", &self.target_id);
459 optional(o, "target_type", &self.target_type);
460 optional(o, "status", &self.status);
461 optional(o, "page", &self.page);
462 optional(o, "limit", &self.limit);
463 }
464}
465
466#[derive(Debug, Clone, Default, PartialEq, Eq)]
468pub struct UserAnimeRatesQuery {
469 pub page: Option<u64>,
471 pub limit: Option<u64>,
473 pub status: Option<UserRateStatus>,
475 pub censored: Option<bool>,
477}
478impl QueryParameters for UserAnimeRatesQuery {
479 fn append_to(&self, o: &mut Vec<(String, String)>) {
480 optional(o, "page", &self.page);
481 optional(o, "limit", &self.limit);
482 optional(o, "status", &self.status);
483 optional_bool(o, "censored", self.censored);
484 }
485}
486
487#[derive(Debug, Clone, Default, PartialEq, Eq)]
489pub struct UserMangaRatesQuery {
490 pub page: Option<u64>,
492 pub limit: Option<u64>,
494 pub censored: Option<bool>,
496}
497impl QueryParameters for UserMangaRatesQuery {
498 fn append_to(&self, o: &mut Vec<(String, String)>) {
499 optional(o, "page", &self.page);
500 optional(o, "limit", &self.limit);
501 optional_bool(o, "censored", self.censored);
502 }
503}
504
505#[derive(Debug, Clone, PartialEq, Eq)]
507pub struct UserMessagesQuery {
508 pub message_type: MessageFolder,
510 pub page: Option<u64>,
512 pub limit: Option<u64>,
514}
515impl QueryParameters for UserMessagesQuery {
516 fn append_to(&self, o: &mut Vec<(String, String)>) {
517 o.push(("type".into(), self.message_type.to_string()));
518 optional(o, "page", &self.page);
519 optional(o, "limit", &self.limit);
520 }
521}
522
523#[derive(Debug, Clone, Default, PartialEq, Eq)]
525pub struct UserHistoryQuery {
526 pub page: Option<u64>,
528 pub limit: Option<u64>,
530 pub target_id: Option<u64>,
532 pub target_type: Option<RateTargetType>,
534}
535impl QueryParameters for UserHistoryQuery {
536 fn append_to(&self, o: &mut Vec<(String, String)>) {
537 optional(o, "page", &self.page);
538 optional(o, "limit", &self.limit);
539 optional(o, "target_id", &self.target_id);
540 optional(o, "target_type", &self.target_type);
541 }
542}
543
544#[derive(Debug, Clone, PartialEq, Eq)]
546pub enum ListValue<T> {
547 Include(T),
549 Exclude(T),
551}
552impl<T: ToString> ::std::fmt::Display for ListValue<T> {
553 fn fmt(&self, formatter: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
554 match self {
555 Self::Include(value) => formatter.write_str(&value.to_string()),
556 Self::Exclude(value) => write!(formatter, "!{}", value.to_string()),
557 }
558 }
559}
560
561macro_rules! string_enum {
562 ($name:ident { $($variant:ident => $value:literal),+ $(,)? }) => {
563 #[doc = concat!("Строго типизированное input-перечисление Shikimori REST API `", stringify!($name), "`.")]
564 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
565 pub enum $name {
566 $(
567 #[doc = concat!("Wire value `", $value, "`, поддерживаемое Shikimori REST API.")]
568 $variant,
569 )+
570 }
571 impl ::std::fmt::Display for $name { fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { f.write_str(match self { $(Self::$variant => $value),+ }) } }
572 impl ::serde::Serialize for $name { fn serialize<S>(&self, serializer: S) -> ::std::result::Result<S::Ok, S::Error> where S: ::serde::Serializer { serializer.serialize_str(&self.to_string()) } }
573 };
574}
575
576string_enum!(AnimeOrder { Id=>"id", IdDesc=>"id_desc", Ranked=>"ranked", Kind=>"kind", Popularity=>"popularity", Name=>"name", AiredOn=>"aired_on", Episodes=>"episodes", Status=>"status", Random=>"random", RankedRandom=>"ranked_random", RankedShiki=>"ranked_shiki", CreatedAt=>"created_at", CreatedAtDesc=>"created_at_desc", UpdatedAt=>"updated_at", UpdatedAtDesc=>"updated_at_desc" });
577string_enum!(MangaOrder { Id=>"id", IdDesc=>"id_desc", Ranked=>"ranked", Kind=>"kind", Popularity=>"popularity", Name=>"name", AiredOn=>"aired_on", Volumes=>"volumes", Chapters=>"chapters", Status=>"status", Random=>"random", RankedRandom=>"ranked_random", RankedShiki=>"ranked_shiki", CreatedAt=>"created_at", CreatedAtDesc=>"created_at_desc", UpdatedAt=>"updated_at", UpdatedAtDesc=>"updated_at_desc" });
578string_enum!(AnimeKind { Tv=>"tv", Movie=>"movie", Ova=>"ova", Ona=>"ona", Special=>"special", TvSpecial=>"tv_special", Music=>"music", Pv=>"pv", Cm=>"cm", Tv13=>"tv_13", Tv24=>"tv_24", Tv48=>"tv_48" });
579string_enum!(AnimeStatus { Anons=>"anons", Ongoing=>"ongoing", Released=>"released" });
580string_enum!(MangaKind { Manga=>"manga", Manhwa=>"manhwa", Manhua=>"manhua", LightNovel=>"light_novel", Novel=>"novel", OneShot=>"one_shot", Doujin=>"doujin" });
581string_enum!(MangaStatus { Anons=>"anons", Ongoing=>"ongoing", Released=>"released", Paused=>"paused", Discontinued=>"discontinued" });
582string_enum!(AnimeDuration { Short=>"S", Medium=>"D", Long=>"F" });
583string_enum!(AgeRating { None=>"none", G=>"g", Pg=>"pg", Pg13=>"pg_13", R=>"r", RPlus=>"r_plus", Rx=>"rx" });
584string_enum!(UserRateStatus { Planned=>"planned", Watching=>"watching", Rewatching=>"rewatching", Completed=>"completed", OnHold=>"on_hold", Dropped=>"dropped" });
585string_enum!(PersonKind { Seyu=>"seyu", Mangaka=>"mangaka", Producer=>"producer" });
586string_enum!(CommentListTarget { Topic=>"Topic", User=>"User" });
587string_enum!(CommentableType { Topic=>"Topic", User=>"User", Anime=>"Anime", Manga=>"Manga", Character=>"Character", Person=>"Person", Article=>"Article", Club=>"Club", ClubPage=>"ClubPage", Collection=>"Collection", Critique=>"Critique", Review=>"Review" });
588string_enum!(RateTargetType { Anime=>"Anime", Manga=>"Manga" });
589string_enum!(FavouriteType { Anime=>"Anime", Manga=>"Manga", Ranobe=>"Ranobe", Person=>"Person", Character=>"Character" });
590string_enum!(PersonFavouriteKind { Common=>"common", Seyu=>"seyu", Mangaka=>"mangaka", Producer=>"producer", Person=>"person" });
591string_enum!(ClubCommentPolicy { Free=>"free", Members=>"members", Admins=>"admins" });
592string_enum!(ClubTopicPolicy { Members=>"members", Admins=>"admins" });
593string_enum!(ClubImageUploadPolicy { Members=>"members", Admins=>"admins" });
594string_enum!(StyleOwnerType { User=>"User", Club=>"Club" });
595string_enum!(ReviewOpinion { Positive=>"positive", Neutral=>"neutral", Negative=>"negative" });
596string_enum!(MessageFolder { Inbox=>"inbox", Private=>"private", Sent=>"sent", News=>"news", Notifications=>"notifications" });
597string_enum!(VideoKind { Pv=>"pv", CharacterTrailer=>"character_trailer", Cm=>"cm", Op=>"op", Ed=>"ed", OpEdClip=>"op_ed_clip", Clip=>"clip", Other=>"other", EpisodePreview=>"episode_preview" });
598string_enum!(TopicForum { All=>"all", Animanga=>"animanga", Site=>"site", Games=>"games", Vn=>"vn", Contests=>"contests", Offtopic=>"offtopic", Clubs=>"clubs", MyClubs=>"my_clubs", Critiques=>"critiques", News=>"news", Collections=>"collections", Articles=>"articles", Cosplay=>"cosplay" });
599string_enum!(TopicLinkedType { Anime=>"Anime", Manga=>"Manga", Ranobe=>"Ranobe", Character=>"Character", Person=>"Person", Club=>"Club", ClubPage=>"ClubPage", Critique=>"Critique", Review=>"Review", Contest=>"Contest", CosplayGallery=>"CosplayGallery", Collection=>"Collection", Article=>"Article" });
600string_enum!(TopicType { Topic=>"Topic", ClubUserTopic=>"Topics::ClubUserTopic", EntryTopic=>"Topics::EntryTopic", AnimeTopic=>"Topics::EntryTopics::AnimeTopic", ArticleTopic=>"Topics::EntryTopics::ArticleTopic", CharacterTopic=>"Topics::EntryTopics::CharacterTopic", ClubPageTopic=>"Topics::EntryTopics::ClubPageTopic", ClubTopic=>"Topics::EntryTopics::ClubTopic", CollectionTopic=>"Topics::EntryTopics::CollectionTopic", ContestTopic=>"Topics::EntryTopics::ContestTopic", CosplayGalleryTopic=>"Topics::EntryTopics::CosplayGalleryTopic", MangaTopic=>"Topics::EntryTopics::MangaTopic", PersonTopic=>"Topics::EntryTopics::PersonTopic", RanobeTopic=>"Topics::EntryTopics::RanobeTopic", CritiqueTopic=>"Topics::EntryTopics::CritiqueTopic", ReviewTopic=>"Topics::EntryTopics::ReviewTopic", NewsTopic=>"Topics::NewsTopic", ContestStatusTopic=>"Topics::NewsTopics::ContestStatusTopic" });
601string_enum!(TopicRootType { Topic=>"Topic" });
602string_enum!(PrivateMessageKind { Private=>"Private" });
603string_enum!(BulkMessageKind { News=>"news", Notifications=>"notifications" });
604
605#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
606pub struct AppearRequest {
608 pub ids: Option<String>,
610}
611#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
612pub struct UpdateClubRequest {
614 pub club: ClubInput,
616}
617#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
618pub struct ClubInput {
620 #[serde(skip_serializing_if = "Option::is_none")]
621 pub name: Option<String>,
623 #[serde(skip_serializing_if = "Option::is_none")]
624 pub description: Option<String>,
626 #[serde(skip_serializing_if = "Option::is_none")]
627 pub display_images: Option<bool>,
629 #[serde(skip_serializing_if = "Option::is_none")]
630 pub comment_policy: Option<ClubCommentPolicy>,
632 #[serde(skip_serializing_if = "Option::is_none")]
633 pub topic_policy: Option<ClubTopicPolicy>,
635 #[serde(skip_serializing_if = "Option::is_none")]
636 pub image_upload_policy: Option<ClubImageUploadPolicy>,
638}
639
640#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
641pub struct CreateCommentRequest {
643 pub comment: NewComment,
645 #[serde(skip_serializing_if = "Option::is_none")]
646 pub frontend: Option<bool>,
648 #[serde(skip_serializing_if = "Option::is_none")]
649 pub broadcast: Option<bool>,
651}
652#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
653pub struct NewComment {
655 pub body: String,
657 pub commentable_id: u64,
659 pub commentable_type: CommentableType,
661 #[serde(skip_serializing_if = "Option::is_none")]
662 pub is_offtopic: Option<bool>,
664}
665#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
666pub struct UpdateCommentRequest {
668 pub comment: CommentPatch,
670 #[serde(skip_serializing_if = "Option::is_none")]
671 pub frontend: Option<bool>,
673}
674#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
675pub struct CommentPatch {
677 pub body: String,
679}
680
681#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
682pub struct CreateTopicRequest {
684 pub topic: NewTopic,
686}
687#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
688pub struct NewTopic {
690 pub body: String,
692 pub forum_id: u64,
694 #[serde(skip_serializing_if = "Option::is_none")]
695 pub linked_id: Option<u64>,
697 #[serde(skip_serializing_if = "Option::is_none")]
698 pub linked_type: Option<TopicLinkedType>,
700 pub title: String,
702 #[serde(rename = "type")]
703 pub topic_type: TopicRootType,
705 pub user_id: u64,
707}
708#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
709pub struct UpdateTopicRequest {
711 pub topic: TopicPatch,
713}
714#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
715pub struct TopicPatch {
717 #[serde(skip_serializing_if = "Option::is_none")]
718 pub body: Option<String>,
720 #[serde(skip_serializing_if = "Option::is_none")]
721 pub linked_id: Option<u64>,
723 #[serde(skip_serializing_if = "Option::is_none")]
724 pub linked_type: Option<TopicLinkedType>,
726 #[serde(skip_serializing_if = "Option::is_none")]
727 pub title: Option<String>,
729}
730
731#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
732pub struct CreateReviewRequest {
734 pub review: NewReview,
736 #[serde(skip_serializing_if = "Option::is_none")]
737 pub frontend: Option<bool>,
739}
740#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
741pub struct NewReview {
743 pub anime_id: u64,
745 pub body: String,
747 pub opinion: ReviewOpinion,
749}
750#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
751pub struct UpdateReviewRequest {
753 pub review: ReviewPatch,
755 #[serde(skip_serializing_if = "Option::is_none")]
756 pub frontend: Option<bool>,
758}
759#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
760pub struct ReviewPatch {
762 #[serde(skip_serializing_if = "Option::is_none")]
763 pub body: Option<String>,
765 #[serde(skip_serializing_if = "Option::is_none")]
766 pub opinion: Option<ReviewOpinion>,
768}
769
770#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
771pub struct CreateMessageRequest {
773 pub message: NewMessage,
775 #[serde(skip_serializing_if = "Option::is_none")]
776 pub frontend: Option<bool>,
778}
779#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
780pub struct NewMessage {
782 pub body: String,
784 pub from_id: u64,
786 pub kind: PrivateMessageKind,
788 pub to_id: u64,
790}
791#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
792pub struct UpdateMessageRequest {
794 pub message: MessagePatch,
796 #[serde(skip_serializing_if = "Option::is_none")]
797 pub frontend: Option<bool>,
799}
800#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
801pub struct MessagePatch {
803 pub body: String,
805}
806#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
807pub struct MarkMessagesReadRequest {
809 #[serde(skip_serializing_if = "Option::is_none")]
810 pub ids: Option<String>,
812 #[serde(skip_serializing_if = "Option::is_none")]
813 pub is_read: Option<bool>,
815}
816#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
817pub struct MessageBulkRequest {
819 #[serde(rename = "type")]
820 pub message_type: BulkMessageKind,
822 #[serde(skip_serializing_if = "Option::is_none")]
823 pub frontend: Option<bool>,
825}
826
827#[derive(Debug, Clone, PartialEq, Eq)]
828pub struct FavouriteTarget {
830 pub linked_type: FavouriteType,
832 pub linked_id: u64,
834 pub kind: Option<PersonFavouriteKind>,
836}
837
838#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
839pub struct CreateUserRateRequest {
841 pub user_rate: NewUserRate,
843}
844#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
845pub struct NewUserRate {
847 pub user_id: u64,
849 pub target_id: u64,
851 pub target_type: RateTargetType,
853 #[serde(skip_serializing_if = "Option::is_none")]
854 pub status: Option<UserRateStatus>,
856 #[serde(skip_serializing_if = "Option::is_none")]
857 pub score: Option<u8>,
859 #[serde(skip_serializing_if = "Option::is_none")]
860 pub chapters: Option<u64>,
862 #[serde(skip_serializing_if = "Option::is_none")]
863 pub episodes: Option<u64>,
865 #[serde(skip_serializing_if = "Option::is_none")]
866 pub volumes: Option<u64>,
868 #[serde(skip_serializing_if = "Option::is_none")]
869 pub rewatches: Option<u64>,
871 #[serde(skip_serializing_if = "Option::is_none")]
872 pub text: Option<String>,
874}
875#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
876pub struct UpdateUserRateRequest {
878 pub user_rate: UserRatePatch,
880}
881#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
882pub struct UserRatePatch {
884 #[serde(skip_serializing_if = "Option::is_none")]
885 pub status: Option<UserRateStatus>,
887 #[serde(skip_serializing_if = "Option::is_none")]
888 pub score: Option<u8>,
890 #[serde(skip_serializing_if = "Option::is_none")]
891 pub chapters: Option<u64>,
893 #[serde(skip_serializing_if = "Option::is_none")]
894 pub episodes: Option<u64>,
896 #[serde(skip_serializing_if = "Option::is_none")]
897 pub volumes: Option<u64>,
899 #[serde(skip_serializing_if = "Option::is_none")]
900 pub rewatches: Option<u64>,
902 #[serde(skip_serializing_if = "Option::is_none")]
903 pub text: Option<String>,
905}
906
907#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
908pub struct CreateTopicIgnoreV1Request {
910 pub topic_ignore: TopicIgnoreInput,
912}
913#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
914pub struct TopicIgnoreInput {
916 #[serde(skip_serializing_if = "Option::is_none")]
917 pub topic_id: Option<u64>,
919 #[serde(skip_serializing_if = "Option::is_none")]
920 pub user_id: Option<u64>,
922}
923
924#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
925pub struct CreateStyleRequest {
927 pub style: NewStyle,
929}
930#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
931pub struct NewStyle {
933 pub css: String,
935 pub name: String,
937 pub owner_id: u64,
939 pub owner_type: StyleOwnerType,
941}
942#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
943pub struct StylePreviewRequest {
945 pub style: StyleCss,
947}
948#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
949pub struct StyleCss {
951 pub css: String,
953}
954#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
955pub struct UpdateStyleRequest {
957 pub style: StylePatch,
959}
960#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
961pub struct StylePatch {
963 #[serde(skip_serializing_if = "Option::is_none")]
964 pub css: Option<String>,
966 #[serde(skip_serializing_if = "Option::is_none")]
967 pub name: Option<String>,
969}
970
971#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
972pub struct CreateVideoRequest {
974 pub video: NewVideo,
976}
977#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
978pub struct NewVideo {
980 pub kind: VideoKind,
982 pub name: String,
984 pub url: String,
986}
987
988#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
989pub struct AbuseRequestInput {
991 #[serde(skip_serializing_if = "Option::is_none")]
992 pub comment_id: Option<u64>,
994 #[serde(skip_serializing_if = "Option::is_none")]
995 pub topic_id: Option<u64>,
997 #[serde(skip_serializing_if = "Option::is_none")]
998 pub reason: Option<String>,
1000}
1001
1002#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1003pub struct EpisodeNotificationRequest {
1005 pub episode_notification: NewEpisodeNotification,
1007 pub token: String,
1009}
1010#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
1011pub struct NewEpisodeNotification {
1013 pub anime_id: u64,
1015 pub episode: u64,
1017 pub aired_at: String,
1019 #[serde(skip_serializing_if = "Option::is_none")]
1020 pub is_fandub: Option<bool>,
1022 #[serde(skip_serializing_if = "Option::is_none")]
1023 pub is_raw: Option<bool>,
1025 #[serde(skip_serializing_if = "Option::is_none")]
1026 pub is_subtitles: Option<bool>,
1028 #[serde(skip_serializing_if = "Option::is_none")]
1029 pub is_anime365: Option<bool>,
1031}
1032
1033#[derive(Debug, Clone, PartialEq, Eq)]
1035pub struct UserImageUpload {
1036 pub filename: String,
1038 pub bytes: Vec<u8>,
1040 pub linked_type: Option<String>,
1042 pub content_type: Option<String>,
1044}
1045
1046#[cfg(test)]
1047mod tests {
1048 use super::*;
1049 #[test]
1050 fn anime_filter_supports_documented_subtraction_mode() {
1051 let query = ListAnimesQuery {
1052 kind: Some(vec![
1053 ListValue::Include(AnimeKind::Tv),
1054 ListValue::Exclude(AnimeKind::Movie),
1055 ]),
1056 ..Default::default()
1057 };
1058 assert_eq!(query.pairs(), vec![("kind".into(), "tv,!movie".into())]);
1059 }
1060}