mangadex 0.1.2

Unofficial asynchronous mangadex API wrapper for rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

//! Chapter data

use chrono::{DateTime, Utc};
use derive_builder::Builder;
use serde::Serialize;
use uuid::Uuid;

use crate::schema::{chapter::*, LanguageCode, NoData};
use crate::Result;

/// Chapter list
///
/// Call to `GET /chapter`
#[derive(Debug, Serialize, Clone, Builder, Default)]
#[serde(rename_all = "camelCase")]
#[builder(setter(strip_option), default)]
pub struct ListChapters<'a> {
    /// Page size
    pub limit: Option<i32>,

    /// Page offset
    pub offset: Option<i32>,

    /// Chapter ids
    #[serde(rename = "ids")]
    #[builder(setter(each = "add_chapter"))]
    pub chapter_ids: Vec<&'a Uuid>,

    /// Chapter title
    pub title: Option<&'a str>,

    /// Groups
    #[builder(setter(each = "add_group"))]
    pub groups: Vec<&'a Uuid>,

    /// Uploader
    pub uploader: Option<&'a Uuid>,

    /// Manga
    pub manga: Option<&'a Uuid>,

    /// Volume
    pub volume: Option<&'a str>,

    /// Chapter
    pub chapter: Option<&'a str>,

    /// Translated language
    pub translated_language: Option<LanguageCode>,

    /// Created after
    pub created_at_since: Option<DateTime<Utc>>,

    /// Updated after
    pub updated_at_since: Option<DateTime<Utc>>,

    /// Published after
    pub publish_at_since: Option<DateTime<Utc>>,

    /// Sort order
    pub order: Option<ChapterOrder>,
}

impl_endpoint! {
    GET "/chapter",
    #[query] ListChapters<'_>,
    ChapterList
}

/// Get chapter
///
/// Call to `GET /chapter/{chapter_id}`
#[derive(Debug, Clone)]
pub struct GetChapter<'a> {
    /// Chapter id
    pub chapter_id: &'a Uuid,
}

impl_endpoint! {
    GET ("/chapter/{:x}", chapter_id),
    #[no_data] GetChapter<'_>,
    #[flatten_result] ChapterResponse
}

/// Update chapter (requires authentication)
///
/// Call to `PUT /chapter/{chapter_id}
#[derive(Debug, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct UpdateChapter<'a> {
    /// Chapter id
    #[serde(skip)]
    pub chapter_id: &'a Uuid,

    /// Chapter title (max length: 255)
    pub title: &'a str,

    /// Chapter volume
    pub volume: Option<&'a str>,

    /// Chapter number (max length: 8)
    pub chapter: Option<&'a str>,

    /// Translated language
    pub translated_language: LanguageCode,

    /// Data quality image names
    pub data: Vec<&'a str>,

    /// Data-saver quality image names
    pub data_saver: Vec<&'a str>,

    /// Chapter version (min: 1)
    pub version: i32,
}

impl_endpoint! {
    PUT ("/chapter/{:x}", chapter_id),
    #[body auth] UpdateChapter<'_>,
    #[flatten_result] ChapterResponse
}

/// Delete a chapter (requires authorization)
///
/// Call to `DELETE /chapter/{id}`
#[derive(Debug, Clone)]
pub struct DeleteChapter<'a> {
    chapter_id: &'a Uuid,
}

impl_endpoint! {
    DELETE ("/chapter/{:x}", chapter_id),
    #[no_data auth] DeleteChapter<'_>,
    #[discard_result] Result<NoData>
}

/// Mark chapter as read (requires authorization)
///
/// Call to `POST /chapter/{id}/read`
#[derive(Debug, Clone)]
pub struct MarkChapterRead<'a> {
    chapter_id: &'a Uuid,
}

impl_endpoint! {
    POST ("/chapter/{:x}/read", chapter_id),
    #[no_data auth] MarkChapterRead<'_>,
    #[discard_result] Result<NoData>
}

/// Mark chapter as unread (requires authorization)
///
/// Call to `DELETE /chapter/{id}/read`
#[derive(Debug, Clone)]
pub struct MarkChapterUnread<'a> {
    chapter_id: &'a Uuid,
}

impl_endpoint! {
    DELETE ("/chapter/{:x}/read", chapter_id),
    #[no_data auth] MarkChapterUnread<'_>,
    #[discard_result] Result<NoData>
}