annis/
lib.rs

1#![doc(html_root_url = "https://!docs.rs/annis/0.0.4")]
2
3//! annis
4//! =====
5//!
6//! The `annis` is a Rust interface to the Annict API.
7//! [Annict API Official Document](https://docs.annict.com/)
8//!
9//! Usage
10//! --------------------
11//! Example: Request to /v1/works
12//! ```no_run
13//! # extern crate annis;
14//! # use annis::{Client, Works, Error, Value};
15//! # use std::env;
16//! #
17//! # fn main() -> Result<(), Error>{
18//! #
19//! let client = Client::set_token("annict_access_token");
20//!
21//! let params = vec![(Works::filter_title, "lain"),(Works::fields, "title")];
22//! let works = annis::works().params(params);
23//!
24//! let json = client.call(works)?.json::<Value>()?;
25//!
26//! println!("{:?}", json["works"]);
27//! #
28//! #   Ok(())  
29//! # }
30//! ```
31
32
33use std::fmt;
34
35use reqwest;
36use serde::{Serialize, Deserialize};
37use serde_json;
38use failure;
39
40mod auth;
41mod client;
42pub mod nonblocking;
43
44pub use crate::auth::*;
45pub use crate::client::Client;
46pub use serde_json::Value;
47
48/// A Service to make request to endpoint.   
49///
50///
51
52#[derive(Debug)]
53pub struct Service<P: Into<String> + std::cmp::PartialEq> {
54    pub method: reqwest::Method,
55    pub url: String,
56    pub params: Option<Vec<(P, String)>>,
57}
58
59impl<P: Into<String> + std::cmp::PartialEq + IsValid> Service<P> {
60    pub fn params<K, V>(self, params: Vec<(K, V)>) -> Service<P>
61    where
62        K: Into<P>,
63        V: Into<String>,
64    {
65        let mut params: Vec<(P, String)> = params
66            .into_iter()
67            .map(|(k, v)| (k.into(), v.into()))
68            .filter(|(k, _)| k.is_valid())
69            .collect();
70        if let Some(mut x) = self.params {
71            params.append(&mut x);
72        };
73        Service {
74            params: Some(params),
75            ..self
76        }
77    }
78}
79
80/// A type of argument for me_records().
81pub enum Method {
82    POST,
83    PATCH,
84    DELETE,
85}
86
87fn request<R: IsValid + Into<String> + std::cmp::PartialEq>(
88    method: reqwest::Method,
89    url: String,
90) -> Service<R> {
91    Service {
92        method: method,
93        url: url,
94        params: None,
95    }
96}
97
98/// Request to /v1/records   
99/// .params() assepts `Records` enum.
100
101pub fn reviews() -> Service<Reviews> {
102    request(
103        reqwest::Method::GET,
104        "https://api.annict.com/v1/records".to_string(),
105    )
106}
107
108/// used by records() function   
109/// /v1/records assepts parameters.
110
111#[allow(non_camel_case_types)]
112#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
113pub enum Reviews {
114    fields,
115    filter_ids,
116    filter_work_id,
117    page,
118    per_page,
119    sort_id,
120    sort_likes_count,
121    Invalid,
122}
123
124impl IsValid for Reviews {
125    fn is_valid(&self) -> bool {
126        *self != Reviews::Invalid
127    }
128}
129
130impl From<Reviews> for String {
131    fn from(p: Reviews) -> String {
132        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
133    }
134}
135
136impl From<&'static str> for Reviews {
137    fn from(p: &'static str) -> Self {
138        serde_json::from_str(p).unwrap_or(Reviews::Invalid)
139    }
140}
141
142impl From<String> for Reviews {
143    fn from(p: String) -> Self {
144        serde_json::from_str(p.as_str()).unwrap_or(Reviews::Invalid)
145    }
146}
147
148impl fmt::Display for Reviews {
149    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
150        write!(f, "{:?}", self)
151    }
152}
153
154/// Request to /v1/users   
155/// .params() assepts `Users` enum.
156
157pub fn users() -> Service<Users> {
158    request(
159        reqwest::Method::GET,
160        "https://api.annict.com/v1/users".to_string(),
161    )
162}
163
164/// used by users() function   
165/// /v1/users assepts parameters.
166
167#[allow(non_camel_case_types)]
168#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
169pub enum Users {
170    fields,
171    filter_ids,
172    filter_usernames,
173    page,
174    per_page,
175    sort_id,
176    Invalid,
177}
178
179impl IsValid for Users {
180    fn is_valid(&self) -> bool {
181        *self != Users::Invalid
182    }
183}
184
185impl From<Users> for String {
186    fn from(p: Users) -> String {
187        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
188    }
189}
190
191impl From<&'static str> for Users {
192    fn from(p: &'static str) -> Self {
193        serde_json::from_str(p).unwrap_or(Users::Invalid)
194    }
195}
196
197impl From<String> for Users {
198    fn from(p: String) -> Self {
199        serde_json::from_str(p.as_str()).unwrap_or(Users::Invalid)
200    }
201}
202
203impl fmt::Display for Users {
204    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
205        write!(f, "{:?}", self)
206    }
207}
208
209/// Request to /v1/following   
210/// .params() assepts `Following` enum.
211
212pub fn following() -> Service<Following> {
213    request(
214        reqwest::Method::GET,
215        "https://api.annict.com/v1/following".to_string(),
216    )
217}
218
219/// used by following() function   
220/// /v1/following assepts parameters.
221
222#[allow(non_camel_case_types)]
223#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
224pub enum Following {
225    fields,
226    filter_user_id,
227    filter_username,
228    page,
229    per_page,
230    sort_id,
231    Invalid,
232}
233
234impl IsValid for Following {
235    fn is_valid(&self) -> bool {
236        *self != Following::Invalid
237    }
238}
239
240impl From<Following> for String {
241    fn from(p: Following) -> String {
242        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
243    }
244}
245
246impl From<&'static str> for Following {
247    fn from(p: &'static str) -> Self {
248        serde_json::from_str(p).unwrap_or(Following::Invalid)
249    }
250}
251
252impl From<String> for Following {
253    fn from(p: String) -> Self {
254        serde_json::from_str(p.as_str()).unwrap_or(Following::Invalid)
255    }
256}
257
258impl fmt::Display for Following {
259    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
260        write!(f, "{:?}", self)
261    }
262}
263
264/// Request to /v1/followers   
265/// .params() assepts `Followers` enum.
266
267pub fn followers() -> Service<Followers> {
268    request(
269        reqwest::Method::GET,
270        "https://api.annict.com/v1/followers".to_string(),
271    )
272}
273
274/// used by followers() function   
275/// /v1/followers assepts parameters.
276
277#[allow(non_camel_case_types)]
278#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
279pub enum Followers {
280    fields,
281    filter_user_id,
282    filter_username,
283    page,
284    per_page,
285    sort_id,
286    Invalid,
287}
288
289impl IsValid for Followers {
290    fn is_valid(&self) -> bool {
291        *self != Followers::Invalid
292    }
293}
294
295impl From<Followers> for String {
296    fn from(p: Followers) -> String {
297        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
298    }
299}
300
301impl From<&'static str> for Followers {
302    fn from(p: &'static str) -> Self {
303        serde_json::from_str(p).unwrap_or(Followers::Invalid)
304    }
305}
306
307impl From<String> for Followers {
308    fn from(p: String) -> Self {
309        serde_json::from_str(p.as_str()).unwrap_or(Followers::Invalid)
310    }
311}
312
313impl fmt::Display for Followers {
314    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
315        write!(f, "{:?}", self)
316    }
317}
318/// Request to /v1/activities   
319/// .params() assepts `Activities` enum.
320
321pub fn activities() -> Service<Activities> {
322    request(
323        reqwest::Method::GET,
324        "https://api.annict.com/v1/activities".to_string(),
325    )
326}
327
328/// used by activities() function   
329/// /v1/activities assepts parameters.
330
331#[allow(non_camel_case_types)]
332#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
333pub enum Activities {
334    fields,
335    filter_users_ids,
336    filter_username,
337    page,
338    per_page,
339    sort_id,
340    Invalid,
341}
342
343impl IsValid for Activities {
344    fn is_valid(&self) -> bool {
345        *self != Activities::Invalid
346    }
347}
348
349impl From<Activities> for String {
350    fn from(p: Activities) -> String {
351        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
352    }
353}
354
355impl From<&'static str> for Activities {
356    fn from(p: &'static str) -> Self {
357        serde_json::from_str(p).unwrap_or(Activities::Invalid)
358    }
359}
360
361impl From<String> for Activities {
362    fn from(p: String) -> Self {
363        serde_json::from_str(p.as_str()).unwrap_or(Activities::Invalid)
364    }
365}
366
367impl fmt::Display for Activities {
368    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
369        write!(f, "{:?}", self)
370    }
371}
372
373/// Request to /v1/me   
374/// .params() assepts `Me` enum.
375
376pub fn me() -> Service<Me> {
377    request(
378        reqwest::Method::GET,
379        "https://api.annict.com/v1/me".to_string(),
380    )
381}
382
383/// used by me() function   
384/// /v1/me assepts parameters.
385
386#[allow(non_camel_case_types)]
387#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
388pub enum Me {
389    fields,
390    Invalid,
391}
392
393impl IsValid for Me {
394    fn is_valid(&self) -> bool {
395        *self != Me::Invalid
396    }
397}
398
399impl From<Me> for String {
400    fn from(p: Me) -> String {
401        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
402    }
403}
404
405impl From<&'static str> for Me {
406    fn from(p: &'static str) -> Self {
407        serde_json::from_str(p).unwrap_or(Me::Invalid)
408    }
409}
410
411impl From<String> for Me {
412    fn from(p: String) -> Self {
413        serde_json::from_str(p.as_str()).unwrap_or(Me::Invalid)
414    }
415}
416
417impl fmt::Display for Me {
418    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
419        write!(f, "{:?}", self)
420    }
421}
422
423/// Request to /v1/me/reviews   
424/// .params() assepts `MeReviews` enum.
425
426pub fn me_reviews(method: Method, id: usize) -> Service<MeReviews> {
427    match method {
428        Method::POST => request(
429            reqwest::Method::POST,
430            "https://api.annict.com/v1/me/reviews".to_string(),
431        )
432        .params(vec![(MeReviews::work_id, id.to_string())]),
433        Method::PATCH => request(
434            reqwest::Method::PATCH,
435            format!("https://api.annict.com/v1/me/reviews/{}", id),
436        ),
437        Method::DELETE => request(
438            reqwest::Method::DELETE,
439            format!("https://api.annict.com/v1/me/reviews/{}", id),
440        ),
441    }
442}
443
444/// used by me_reviews() function   
445/// /v1/me/reviews assepts parameters.
446
447#[allow(non_camel_case_types)]
448#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
449pub enum MeReviews {
450    work_id,
451    title,
452    body,
453    rating_animation_state,
454    rating_music_state,
455    rating_story_state,
456    rating_character_state,
457    rating_overall_state,
458    share_twitter,
459    share_facebook,
460    Invalid,
461}
462
463impl IsValid for MeReviews {
464    fn is_valid(&self) -> bool {
465        *self != MeReviews::Invalid
466    }
467}
468
469impl From<MeReviews> for String {
470    fn from(p: MeReviews) -> String {
471        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
472    }
473}
474
475impl From<&'static str> for MeReviews {
476    fn from(p: &'static str) -> Self {
477        serde_json::from_str(p).unwrap_or(MeReviews::Invalid)
478    }
479}
480
481impl From<String> for MeReviews {
482    fn from(p: String) -> Self {
483        serde_json::from_str(p.as_str()).unwrap_or(MeReviews::Invalid)
484    }
485}
486
487impl fmt::Display for MeReviews {
488    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
489        write!(f, "{:?}", self)
490    }
491}
492
493/// Request to /v1/me/following_activities   
494/// .params() assepts `MeFollowing_activities` enum.
495
496pub fn me_following_activities() -> Service<MeFollowing_activities> {
497    request(
498        reqwest::Method::GET,
499        "https://api.annict.com/v1/me/following_activities".to_string(),
500    )
501}
502
503/// used by me_following_activities() function   
504/// /v1/me/following_activities assepts parameters.
505
506#[allow(non_camel_case_types)]
507#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
508pub enum MeFollowing_activities {
509    fields,
510    filter_actions,
511    filter_muted,
512    page,
513    per_page,
514    sort_id,
515    Invalid,
516}
517
518impl IsValid for MeFollowing_activities {
519    fn is_valid(&self) -> bool {
520        *self != MeFollowing_activities::Invalid
521    }
522}
523
524impl From<MeFollowing_activities> for String {
525    fn from(p: MeFollowing_activities) -> String {
526        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
527    }
528}
529
530impl From<&'static str> for MeFollowing_activities {
531    fn from(p: &'static str) -> Self {
532        serde_json::from_str(p).unwrap_or(MeFollowing_activities::Invalid)
533    }
534}
535
536impl From<String> for MeFollowing_activities {
537    fn from(p: String) -> Self {
538        serde_json::from_str(p.as_str()).unwrap_or(MeFollowing_activities::Invalid)
539    }
540}
541
542impl fmt::Display for MeFollowing_activities {
543    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
544        write!(f, "{:?}", self)
545    }
546}
547
548/// Request to /v1/works   
549/// .params() assepts `Works` enum.
550///
551/// Examples
552/// ========
553/// ```rust
554/// # use annis::{Client, Error};
555/// #
556/// # fn run() -> Result<(), Error> {
557/// let client = Client::set_token("annict_access_token");
558///
559/// let works = annis::works().params(vec![("filter_title", "lain")]);
560///
561/// client.call(works)?;
562/// # Ok(())
563/// # }
564/// ```
565///
566/// using enum code
567/// ```rust
568/// # use annis::{Client, Error};
569/// #
570/// # fn run() -> Result<(), Error> {
571/// use annis::Works::*;
572///
573/// let client = Client::set_token("annict_access_token");
574///
575/// let works = annis::works().params(vec![(filter_title, "lain")]);
576///
577/// client.call(works)?;
578/// # Ok(())
579/// # }
580/// ```
581
582pub fn works() -> Service<Works> {
583    Service {
584        method: reqwest::Method::GET,
585        url: "https://api.annict.com/v1/works".to_string(),
586        params: None,
587    }
588}
589
590/// Request to /v1/episodes   
591/// .params() assepts `Episodes` enum.
592///
593/// Examples
594/// ========
595/// ```rust
596/// # use annis::{Client, Error};
597/// #
598/// # fn run() -> Result<(), Error> {
599/// let client = Client::set_token("annict_access_token");
600///
601/// let episodes = annis::episodes().params(vec![("filter_work_id", "2274")]);
602///
603/// client.call(episodes)?;
604/// # Ok(())
605/// # }
606/// ```
607///
608/// using enum code
609/// ```rust
610/// # use annis::{Client, Error};
611/// #
612/// # fn run() -> Result<(), Error> {
613/// use annis::Episodes::*;
614///
615/// let client = Client::set_token("annict_access_token");
616///
617/// let episodes = annis::episodes().params(vec![(filter_work_id, "2274")]);
618///
619/// client.call(episodes)?;
620/// # Ok(())
621/// # }
622/// ```
623
624pub fn episodes() -> Service<Episodes> {
625    Service {
626        method: reqwest::Method::GET,
627        url: "https://api.annict.com/v1/episodes".to_string(),
628        params: None,
629    }
630}
631
632/// Request to /v1/records   
633/// .params() assepts `Records` enum.
634///
635/// Examples
636/// ========
637/// ```rust
638/// # use annis::{Client, Error};
639/// #
640/// # fn run() -> Result<(), Error> {
641/// let client = Client::set_token("annict_access_token");
642///
643/// let records = annis::records().params(vec![("fields", "title")]);
644///
645/// client.call(records)?;
646/// # Ok(())
647/// # }
648/// ```
649///
650/// using enum code.
651/// ```rust
652/// # use annis::{Client, Error};
653/// #
654/// # fn run() -> Result<(), Error> {
655/// use annis::Records::*;
656///
657/// let client = Client::set_token("annict_access_token");
658///
659/// let records = annis::records().params(vec![(fields, "title")]);
660///
661/// client.call(records)?;
662/// # Ok(())
663/// # }
664/// ```
665
666pub fn records() -> Service<Records> {
667    Service {
668        method: reqwest::Method::GET,
669        url: "https://api.annict.com/v1/records".to_string(),
670        params: None,
671    }
672}
673
674/// Request to /v1/me/statuses   
675/// .params() assepts `MeStatuses` enum.
676///
677/// Examples
678/// ========
679/// ```rust
680/// # use annis::{Client, Error};
681/// #
682/// # fn run() -> Result<(), Error> {
683/// let client = Client::set_token("annict_access_token");
684///
685/// let statuses = annis::me_statuses().params(vec![("work_id", "3994"), ("kind", "watched")]);
686///
687/// client.call(statuses)?;
688/// # Ok(())
689/// # }
690/// ```
691///
692/// using enum code.
693/// ```rust
694/// # use annis::{Client, Error};
695/// #
696/// # fn run() -> Result<(), Error> {
697/// use annis::MeStatuses::*;
698///
699/// let client = Client::set_token("annict_access_token");
700///
701/// let statuses = annis::me_statuses().params(vec![(work_id, "3994"), (kind, "watched")]);
702///
703/// client.call(statuses)?;
704/// # Ok(())
705/// # }
706/// ```
707
708pub fn me_statuses() -> Service<MeStatuses> {
709    Service {
710        method: reqwest::Method::POST,
711        url: "https://api.annict.com/v1/me/statuses".to_string(),
712        params: None,
713    }
714}
715
716/// Request to /v1/me/records   
717/// .params() assepts `MeRecords` enum.
718///
719/// Examples
720/// ========
721///
722/// POST
723/// ```rust
724/// # use annis::{Client, Method, Error};
725/// #
726/// # fn post() -> Result<(), Error> {
727/// let client = Client::set_token("annict_access_token");
728///
729/// let records = annis::me_records(Method::POST, 5013).params(vec![("episode_id", "5013"), ("rating", "5")]);
730///
731/// client.call(records)?;
732/// # Ok(())
733/// # }
734/// ```
735/// PATCH
736/// ```rust
737/// # use annis::{Client, Method, Error};
738/// #
739/// # fn patch() -> Result<(), Error> {
740/// let client = Client::set_token("annict_access_token");
741///
742/// let records = annis::me_records(Method::PATCH, 1838569).params(vec![("rating", "5")]);
743///
744/// client.call(records)?;
745/// # Ok(())
746/// # }
747/// ```
748///
749/// using enum code
750/// ****************
751/// POST
752/// ```rust
753/// # use annis::{Client, Method, Error};
754/// #
755/// # fn post() -> Result<(), Error> {
756/// use annis::MeRecords::*;
757///
758/// let client = Client::set_token("annict_access_token");
759///
760/// let records = annis::me_records(Method::POST, 5013).params(vec![(episode_id, "5013"), (rating, "5")]);
761///
762/// client.call(records)?;
763/// # Ok(())
764/// # }
765/// ```
766/// PATCH
767/// ```rust
768/// # use annis::{Client, Method, Error};
769/// #
770/// # fn patch() -> Result<(), Error> {
771/// use annis::MeRecords::*;
772///
773/// let client = Client::set_token("annict_access_token");
774///
775/// let records = annis::me_records(Method::PATCH , 1838569).params(vec![(rating, "5")]);
776///
777/// client.call(records)?;
778/// # Ok(())
779/// # }
780/// ```
781
782pub fn me_records(method: Method, id: usize) -> Service<MeRecords> {
783    let (method, url, params): (reqwest::Method, String, Option<Vec<(MeRecords, String)>>) =
784        match method {
785            Method::POST => (
786                reqwest::Method::POST,
787                "https://api.annict.com/v1/me/records".to_string(),
788                Some(vec![(MeRecords::episode_id, id.to_string())]),
789            ),
790            Method::PATCH => (
791                reqwest::Method::PATCH,
792                format!("https://api.annict.com/v1/me/records/{}", id),
793                None,
794            ),
795            Method::DELETE => (
796                reqwest::Method::DELETE,
797                format!("https://api.annict.com/v1/me/records/{}", id),
798                None,
799            ),
800        };
801
802    Service {
803        method: method,
804        url: url,
805        params: params,
806    }
807}
808
809/// Request to /v1/me/works   
810/// .params() assepts `MeWorks` enum.
811///
812/// Examples
813/// ========
814/// ```rust
815/// # use annis::{Client, Error};
816/// #
817/// # fn run() -> Result<(), Error> {
818/// let client = Client::set_token("annict_access_token");
819///
820/// let me_works = annis::me_works().params(vec![("filter_title","機動戦士ガンダムUC")]);
821///
822/// client.call(me_works)?;
823/// # Ok(())
824/// # }
825/// ```
826/// using enum code
827/// ```rust
828/// # use annis::{Client, Error};
829/// #
830/// # fn run() -> Result<(), Error> {
831/// use annis::MeWorks::*;
832///
833/// let client = Client::set_token("annict_access_token");
834///
835/// let me_works = annis::me_works().params(vec![(filter_title,"機動戦士ガンダムUC")]);
836///
837/// client.call(me_works)?;
838/// # Ok(())
839/// # }
840/// ```
841
842pub fn me_works() -> Service<MeWorks> {
843    Service {
844        method: reqwest::Method::GET,
845        url: "https://api.annict.com/v1/me/works".to_string(),
846        params: None,
847    }
848}
849
850/// Request to /v1/me/programs   
851/// .params() assepts `MePrograms` enum.
852///
853/// Examples
854/// ========
855///
856/// ```rust
857/// # use annis::{Client, Error};
858/// #
859/// # fn run() -> Result<(), Error> {
860/// let client = Client::set_token("annict_access_token");
861///
862/// let programs = annis::me_programs().params(vec![("field", "id, title")]);
863///
864/// client.call(programs)?;
865/// # Ok(())
866/// # }
867/// ```
868/// using enum code
869/// ```rust
870/// # use annis::{Client, Error};
871/// #
872/// # fn run() -> Result<(), Error> {
873/// use annis::MePrograms::*;
874///
875/// let client = Client::set_token("annict_access_token");
876///
877/// let programs = annis::me_programs().params(vec![(fields, "id, title")]);
878///
879/// client.call(programs)?;
880/// # Ok(())
881/// # }
882/// ```
883
884pub fn me_programs() -> Service<MePrograms> {
885    Service {
886        method: reqwest::Method::GET,
887        url: "https://api.annict.com/v1/me/programs".to_string(),
888        params: None,
889    }
890}
891
892pub trait IsValid {
893    fn is_valid(&self) -> bool;
894}
895
896/// used by works() function   
897/// /v1/works assepts parameters.
898
899#[allow(non_camel_case_types)]
900#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
901pub enum Works {
902    fields,
903    filter_ids,
904    filter_season,
905    filter_title,
906    page,
907    per_page,
908    sort_id,
909    sort_season,
910    sort_watchers_count,
911    Invalid,
912}
913
914impl IsValid for Works {
915    fn is_valid(&self) -> bool {
916        *self != Works::Invalid
917    }
918}
919
920impl From<Works> for String {
921    fn from(p: Works) -> String {
922        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
923    }
924}
925
926impl From<&'static str> for Works {
927    fn from(p: &'static str) -> Self {
928        serde_json::from_str(p).unwrap_or(Works::Invalid)
929    }
930}
931
932impl From<String> for Works {
933    fn from(p: String) -> Self {
934        serde_json::from_str(p.as_str()).unwrap_or(Works::Invalid)
935    }
936}
937
938impl fmt::Display for Works {
939    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
940        write!(f, "{:?}", self)
941    }
942}
943
944/// used by episodes() function   
945/// /v1/episodes assepts parameters.
946
947#[allow(non_camel_case_types)]
948#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
949pub enum Episodes {
950    fields,
951    filter_ids,
952    filter_work_id,
953    page,
954    per_page,
955    sort_id,
956    sort_sort_number,
957    Invalid,
958}
959
960impl IsValid for Episodes {
961    fn is_valid(&self) -> bool {
962        *self != Episodes::Invalid
963    }
964}
965
966impl From<Episodes> for String {
967    fn from(p: Episodes) -> String {
968        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
969    }
970}
971
972impl From<&'static str> for Episodes {
973    fn from(p: &'static str) -> Episodes {
974        serde_json::from_str(p).unwrap_or(Episodes::Invalid)
975    }
976}
977
978impl From<String> for Episodes {
979    fn from(p: String) -> Self {
980        serde_json::from_str(p.as_str()).unwrap_or(Episodes::Invalid)
981    }
982}
983
984impl fmt::Display for Episodes {
985    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
986        write!(f, "{:?}", self)
987    }
988}
989
990/// used by records() function   
991/// /v1/records assepts parameters.
992
993#[allow(non_camel_case_types)]
994#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
995pub enum Records {
996    fields,
997    filter_ids,
998    filter_episode_id,
999    page,
1000    per_page,
1001    sort_id,
1002    sort_likes_count,
1003    Invalid,
1004}
1005
1006impl IsValid for Records {
1007    fn is_valid(&self) -> bool {
1008        *self != Records::Invalid
1009    }
1010}
1011
1012impl From<Records> for String {
1013    fn from(p: Records) -> String {
1014        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1015    }
1016}
1017
1018impl From<&'static str> for Records {
1019    fn from(p: &'static str) -> Self {
1020        serde_json::from_str(p).unwrap_or(Records::Invalid)
1021    }
1022}
1023
1024impl From<String> for Records {
1025    fn from(p: String) -> Self {
1026        serde_json::from_str(p.as_str()).unwrap_or(Records::Invalid)
1027    }
1028}
1029
1030impl fmt::Display for Records {
1031    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1032        write!(f, "{:?}", self)
1033    }
1034}
1035
1036/// used by me_statuses() function   
1037/// /v1/me/statuses assepts parameters.
1038
1039#[allow(non_camel_case_types)]
1040#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1041pub enum MeStatuses {
1042    work_id,
1043    kind,
1044    Invalid,
1045}
1046
1047impl IsValid for MeStatuses {
1048    fn is_valid(&self) -> bool {
1049        *self != MeStatuses::Invalid
1050    }
1051}
1052
1053impl From<MeStatuses> for String {
1054    fn from(p: MeStatuses) -> String {
1055        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1056    }
1057}
1058
1059impl From<&'static str> for MeStatuses {
1060    fn from(p: &'static str) -> Self {
1061        serde_json::from_str(p).unwrap_or(MeStatuses::Invalid)
1062    }
1063}
1064
1065impl From<String> for MeStatuses {
1066    fn from(p: String) -> Self {
1067        serde_json::from_str(p.as_str()).unwrap_or(MeStatuses::Invalid)
1068    }
1069}
1070
1071impl fmt::Display for MeStatuses {
1072    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1073        write!(f, "{:?}", self)
1074    }
1075}
1076
1077/// used by me_records() function   
1078/// /v1/me/records assepts parameters.
1079
1080#[allow(non_camel_case_types)]
1081#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1082pub enum MeRecords {
1083    episode_id,
1084    comment,
1085    rating,
1086    share_twitter,
1087    share_facebook,
1088    Invalid,
1089}
1090
1091impl IsValid for MeRecords {
1092    fn is_valid(&self) -> bool {
1093        *self != MeRecords::Invalid
1094    }
1095}
1096
1097impl From<MeRecords> for String {
1098    fn from(p: MeRecords) -> String {
1099        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1100    }
1101}
1102
1103impl From<&'static str> for MeRecords {
1104    fn from(p: &'static str) -> Self {
1105        serde_json::from_str(p).unwrap_or(MeRecords::Invalid)
1106    }
1107}
1108
1109impl From<String> for MeRecords {
1110    fn from(p: String) -> Self {
1111        serde_json::from_str(p.as_str()).unwrap_or(MeRecords::Invalid)
1112    }
1113}
1114
1115impl fmt::Display for MeRecords {
1116    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1117        write!(f, "{:?}", self)
1118    }
1119}
1120
1121/// used by me_works() function   
1122/// /v1/me/works assepts parameters.
1123
1124#[allow(non_camel_case_types)]
1125#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1126pub enum MeWorks {
1127    fields,
1128    filter_ids,
1129    filter_season,
1130    filter_title,
1131    filter_status,
1132    page,
1133    per_page,
1134    sort_id,
1135    sort_season,
1136    sort_watchers_count,
1137    Invalid,
1138}
1139
1140impl IsValid for MeWorks {
1141    fn is_valid(&self) -> bool {
1142        *self != MeWorks::Invalid
1143    }
1144}
1145
1146impl From<MeWorks> for String {
1147    fn from(p: MeWorks) -> String {
1148        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1149    }
1150}
1151
1152impl From<&'static str> for MeWorks {
1153    fn from(p: &'static str) -> Self {
1154        serde_json::from_str(p).unwrap_or(MeWorks::Invalid)
1155    }
1156}
1157
1158impl From<String> for MeWorks {
1159    fn from(p: String) -> Self {
1160        serde_json::from_str(p.as_str()).unwrap_or(MeWorks::Invalid)
1161    }
1162}
1163
1164impl fmt::Display for MeWorks {
1165    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1166        write!(f, "{:?}", self)
1167    }
1168}
1169
1170/// used by me_programs() function   
1171/// /v1/me/programs assepts parameters.
1172
1173#[allow(non_camel_case_types)]
1174#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1175pub enum MePrograms {
1176    fields,
1177    filter_ids,
1178    filter_channel_ids,
1179    filter_work_ids,
1180    filter_started_at_gt,
1181    filter_started_at_lt,
1182    filter_unwatched,
1183    filter_rebroadcast,
1184    page,
1185    per_page,
1186    sort_id,
1187    sort_started_at,
1188    Invalid,
1189}
1190
1191impl IsValid for MePrograms {
1192    fn is_valid(&self) -> bool {
1193        *self != MePrograms::Invalid
1194    }
1195}
1196
1197impl From<MePrograms> for String {
1198    fn from(p: MePrograms) -> String {
1199        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1200    }
1201}
1202
1203impl From<&'static str> for MePrograms {
1204    fn from(p: &'static str) -> Self {
1205        serde_json::from_str(p).unwrap_or(MePrograms::Invalid)
1206    }
1207}
1208
1209impl From<String> for MePrograms {
1210    fn from(p: String) -> Self {
1211        serde_json::from_str(p.as_str()).unwrap_or(MePrograms::Invalid)
1212    }
1213}
1214
1215impl fmt::Display for MePrograms {
1216    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1217        write!(f, "{:?}", self)
1218    }
1219}
1220
1221
1222/// Request to /v1/people   
1223/// .params() assepts `People` enum.
1224
1225pub fn people() -> Service<People>{
1226    Service{
1227        method: reqwest::Method::GET,
1228        url: "https://api.annict.com/v1/people".to_string(),
1229        params: None,
1230    }
1231}
1232
1233/// used by people() function   
1234/// /v1/people assepts parameters.
1235
1236#[allow(non_camel_case_types)]
1237#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1238pub enum People {
1239    fields,
1240    filter_ids,
1241    filter_name,
1242    page,
1243    per_page,
1244    sort_id,
1245    Invalid,
1246}
1247
1248impl IsValid for People {
1249    fn is_valid(&self) -> bool {
1250        *self != People::Invalid
1251    }
1252}
1253
1254impl From<People> for String {
1255    fn from(p: People) -> String {
1256        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1257    }
1258}
1259
1260impl From<&'static str> for People {
1261    fn from(p: &'static str) -> Self {
1262        serde_json::from_str(p).unwrap_or(People::Invalid)
1263    }
1264}
1265
1266impl From<String> for People {
1267    fn from(p: String) -> Self {
1268        serde_json::from_str(p.as_str()).unwrap_or(People::Invalid)
1269    }
1270}
1271
1272impl fmt::Display for People {
1273    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1274        write!(f, "{:?}", self)
1275    }
1276}
1277
1278/// Request to /v1/organizations   
1279/// .params() assepts `Organizations` enum.
1280
1281pub fn organizations() -> Service<Organizations>{
1282    Service{
1283        method: reqwest::Method::GET,
1284        url: "https://api.annict.com/v1/organizations".to_string(),
1285        params: None,
1286    }
1287}
1288
1289/// used by organizations() function   
1290/// /v1/organizations assepts parameters.
1291
1292#[allow(non_camel_case_types)]
1293#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1294pub enum Organizations {
1295    fields,
1296    filter_ids,
1297    filter_name,
1298    page,
1299    per_page,
1300    sort_id,
1301    Invalid,
1302}
1303
1304impl IsValid for Organizations {
1305    fn is_valid(&self) -> bool {
1306        *self != Organizations::Invalid
1307    }
1308}
1309
1310impl From<Organizations> for String {
1311    fn from(p: Organizations) -> String {
1312        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1313    }
1314}
1315
1316impl From<&'static str> for Organizations {
1317    fn from(p: &'static str) -> Self {
1318        serde_json::from_str(p).unwrap_or(Organizations::Invalid)
1319    }
1320}
1321
1322impl From<String> for Organizations {
1323    fn from(p: String) -> Self {
1324        serde_json::from_str(p.as_str()).unwrap_or(Organizations::Invalid)
1325    }
1326}
1327
1328impl fmt::Display for Organizations {
1329    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1330        write!(f, "{:?}", self)
1331    }
1332}
1333
1334/// Request to /v1/series   
1335/// .params() assepts `Series` enum.
1336
1337pub fn series() -> Service<Series>{
1338    Service{
1339        method: reqwest::Method::GET,
1340        url: "https://api.annict.com/v1/series".to_string(),
1341        params: None,
1342    }
1343}
1344
1345/// used by series() function   
1346/// /v1/series assepts parameters.
1347
1348#[allow(non_camel_case_types)]
1349#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1350pub enum Series {
1351    fields,
1352    filter_ids,
1353    filter_name,
1354    page,
1355    per_page,
1356    sort_id,
1357    Invalid,
1358}
1359
1360impl IsValid for Series {
1361    fn is_valid(&self) -> bool {
1362        *self != Series::Invalid
1363    }
1364}
1365
1366impl From<Series> for String {
1367    fn from(p: Series) -> String {
1368        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1369    }
1370}
1371
1372impl From<&'static str> for Series {
1373    fn from(p: &'static str) -> Self {
1374        serde_json::from_str(p).unwrap_or(Series::Invalid)
1375    }
1376}
1377
1378impl From<String> for Series {
1379    fn from(p: String) -> Self {
1380        serde_json::from_str(p.as_str()).unwrap_or(Series::Invalid)
1381    }
1382}
1383
1384impl fmt::Display for Series {
1385    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1386        write!(f, "{:?}", self)
1387    }
1388}
1389
1390/// Request to /v1/characters   
1391/// .params() assepts `Characters` enum.
1392
1393pub fn characters() -> Service<Characters>{
1394    Service{
1395        method: reqwest::Method::GET,
1396        url: "https://api.annict.com/v1/characters".to_string(),
1397        params: None,
1398    }
1399}
1400
1401/// used by characters() function   
1402/// /v1/characters assepts parameters.
1403
1404#[allow(non_camel_case_types)]
1405#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1406pub enum Characters {
1407    fields,
1408    filter_ids,
1409    filter_name,
1410    page,
1411    per_page,
1412    sort_id,
1413    Invalid,
1414}
1415
1416impl IsValid for Characters {
1417    fn is_valid(&self) -> bool {
1418        *self != Characters::Invalid
1419    }
1420}
1421
1422impl From<Characters> for String {
1423    fn from(p: Characters) -> String {
1424        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1425    }
1426}
1427
1428impl From<&'static str> for Characters {
1429    fn from(p: &'static str) -> Self {
1430        serde_json::from_str(p).unwrap_or(Characters::Invalid)
1431    }
1432}
1433
1434impl From<String> for Characters {
1435    fn from(p: String) -> Self {
1436        serde_json::from_str(p.as_str()).unwrap_or(Characters::Invalid)
1437    }
1438}
1439
1440impl fmt::Display for Characters {
1441    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1442        write!(f, "{:?}", self)
1443    }
1444}
1445
1446/// Request to /v1/casts   
1447/// .params() assepts `Casts` enum.
1448
1449pub fn casts() -> Service<Casts>{
1450    Service{
1451        method: reqwest::Method::GET,
1452        url: "https://api.annict.com/v1/casts".to_string(),
1453        params: None,
1454    }
1455}
1456
1457/// used by casts() function   
1458/// /v1/casts assepts parameters.
1459
1460#[allow(non_camel_case_types)]
1461#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1462pub enum Casts {
1463    fields,
1464    filter_ids,
1465    filter_work_id,
1466    page,
1467    per_page,
1468    sort_id,
1469    sort_sort_number,
1470    Invalid,
1471}
1472
1473impl IsValid for Casts {
1474    fn is_valid(&self) -> bool {
1475        *self != Casts::Invalid
1476    }
1477}
1478
1479impl From<Casts> for String {
1480    fn from(p: Casts) -> String {
1481        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1482    }
1483}
1484
1485impl From<&'static str> for Casts {
1486    fn from(p: &'static str) -> Self {
1487        serde_json::from_str(p).unwrap_or(Casts::Invalid)
1488    }
1489}
1490
1491impl From<String> for Casts {
1492    fn from(p: String) -> Self {
1493        serde_json::from_str(p.as_str()).unwrap_or(Casts::Invalid)
1494    }
1495}
1496
1497impl fmt::Display for Casts {
1498    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1499        write!(f, "{:?}", self)
1500    }
1501}
1502
1503/// Request to /v1/staffs   
1504/// .params() assepts `Staffs` enum.
1505
1506pub fn staffs() -> Service<Staffs>{
1507    Service{
1508        method: reqwest::Method::GET,
1509        url: "https://api.annict.com/v1/staffs".to_string(),
1510        params: None,
1511    }
1512}
1513
1514/// used by staffs() function   
1515/// /v1/staffs assepts parameters.
1516
1517#[allow(non_camel_case_types)]
1518#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1519pub enum Staffs {
1520    fields,
1521    filter_ids,
1522    filter_name,
1523    page,
1524    per_page,
1525    sort_id,
1526    Invalid,
1527}
1528
1529impl IsValid for Staffs {
1530    fn is_valid(&self) -> bool {
1531        *self != Staffs::Invalid
1532    }
1533}
1534
1535impl From<Staffs> for String {
1536    fn from(p: Staffs) -> String {
1537        serde_json::to_string(&p).unwrap_or(String::from("invalid parameter"))
1538    }
1539}
1540
1541impl From<&'static str> for Staffs {
1542    fn from(p: &'static str) -> Self {
1543        serde_json::from_str(p).unwrap_or(Staffs::Invalid)
1544    }
1545}
1546
1547impl From<String> for Staffs {
1548    fn from(p: String) -> Self {
1549        serde_json::from_str(p.as_str()).unwrap_or(Staffs::Invalid)
1550    }
1551}
1552
1553impl fmt::Display for Staffs {
1554    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1555        write!(f, "{:?}", self)
1556    }
1557}
1558
1559// -------------------------------------------------
1560
1561#[derive(Fail, Debug)]
1562pub enum ErrorKind {
1563    #[fail(display = "Invalid value at token or request parameters")]
1564    InvalidValue,
1565}
1566
1567/* ----------- failure boilerplate ----------- */
1568
1569use failure::{Backtrace, Context, Fail};
1570use std::fmt::Display;
1571
1572#[derive(Debug)]
1573pub struct Error {
1574    inner: Context<ErrorKind>,
1575}
1576
1577impl Fail for Error {
1578    fn cause(&self) -> Option<&dyn Fail> {
1579        self.inner.cause()
1580    }
1581
1582    fn backtrace(&self) -> Option<&Backtrace> {
1583        self.inner.backtrace()
1584    }
1585}
1586
1587impl Display for Error {
1588    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1589        Display::fmt(&self.inner, f)
1590    }
1591}
1592
1593impl Error {
1594    pub fn new(inner: Context<ErrorKind>) -> Error {
1595        Error { inner }
1596    }
1597
1598    pub fn kind(&self) -> &ErrorKind {
1599        self.inner.get_context()
1600    }
1601}
1602
1603impl From<ErrorKind> for Error {
1604    fn from(kind: ErrorKind) -> Error {
1605        Error {
1606            inner: Context::new(kind),
1607        }
1608    }
1609}
1610
1611impl From<Context<ErrorKind>> for Error {
1612    fn from(inner: Context<ErrorKind>) -> Error {
1613        Error { inner }
1614    }
1615}
1616
1617impl From<reqwest::Error> for Error {
1618    fn from(error: reqwest::Error) -> Error {
1619        Error {
1620            inner: error.context(ErrorKind::InvalidValue),
1621        }
1622    }
1623}
annis/lib.rs

annis/
lib.rs
