Tested Upload 🎉

Author: tonymushah

mangadex-api-params-types/src/lib.rs

@@ -11,3 +11,11 @@ pub mod forums;
 pub mod legacy;
 pub mod manga;
 pub mod oauth;
+pub mod rating;
+pub mod read_marker;
+pub mod report;
+pub mod scanlation_group;
+pub mod settings;
+pub mod statistics;
+pub mod upload;
+pub mod user;

mangadex-api-params-types/src/rating.rs

@@ -0,0 +1 @@
+pub mod create_or_update;

mangadex-api-params-types/src/rating/create_or_update.rs

@@ -0,0 +1,37 @@
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api::{v5::rating::manga_id::post::CreateUpdateMangaRatingBuilder, MangaDexClient};
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Type, Serialize, Deserialize)]
+pub struct CreateUpdateRating {
+    pub manga_id: Uuid,
+
+    /// `[ 1 .. 10 ]`.
+    ///
+    /// Numbers below `1` will be set at `1` and numbers above `10` will be set at `10`.
+    pub rating: u8,
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl From<CreateUpdateRating> for CreateUpdateMangaRatingBuilder {
+    fn from(value: CreateUpdateRating) -> Self {
+        let mut builder = Self::default();
+        builder.manga_id(value.manga_id);
+        builder.rating(value.rating);
+        builder
+    }
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl CreateUpdateRating {
+    pub async fn send(self, client: &MangaDexClient) -> mangadex_api_types::error::Result<()> {
+        <CreateUpdateMangaRatingBuilder as From<Self>>::from(self)
+            .http_client(client.get_http_client().clone())
+            .send()
+            .await?;
+        Ok(())
+    }
+}

mangadex-api-params-types/src/read_marker.rs

@@ -0,0 +1,2 @@
+pub mod batch_read_marker;
+pub mod read_markers;

mangadex-api-params-types/src/read_marker/batch_read_marker.rs

@@ -0,0 +1,40 @@
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api::{v5::manga::id::read::post::MarkChapterBatchBuilder, MangaDexClient};
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Type, Serialize, Deserialize)]
+pub struct MarkChapterBatchParam {
+    pub manga_id: Uuid,
+    #[serde(default)]
+    pub chapter_ids_read: Vec<Uuid>,
+    #[serde(default)]
+    pub chapter_ids_unread: Vec<Uuid>,
+    #[serde(default)]
+    pub update_history: bool,
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl From<MarkChapterBatchParam> for MarkChapterBatchBuilder {
+    fn from(value: MarkChapterBatchParam) -> Self {
+        let mut builder = Self::default();
+        builder.manga_id(value.manga_id);
+        builder.chapter_ids_read(value.chapter_ids_read);
+        builder.chapter_ids_unread(value.chapter_ids_unread);
+        builder.update_history(value.update_history);
+        builder
+    }
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl MarkChapterBatchParam {
+    pub async fn send(self, client: &MangaDexClient) -> mangadex_api_types::error::Result<()> {
+        <MarkChapterBatchBuilder as From<Self>>::from(self)
+            .http_client(client.get_http_client().clone())
+            .send()
+            .await?;
+        Ok(())
+    }
+}

mangadex-api-params-types/src/read_marker/read_markers.rs

@@ -0,0 +1,36 @@
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api::{v5::manga::read::get::GetReadChaptersBuilder, MangaDexClient};
+
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Type, Serialize, Deserialize)]
+pub struct ChapterReadMarkersParam {
+    pub manga_ids: Vec<Uuid>,
+    #[serde(default)]
+    pub grouped: bool,
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl From<ChapterReadMarkersParam> for GetReadChaptersBuilder {
+    fn from(value: ChapterReadMarkersParam) -> Self {
+        let mut builder = Self::default();
+        builder.manga_ids(value.manga_ids);
+        builder.grouped(value.grouped);
+        builder
+    }
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl ChapterReadMarkersParam {
+    pub async fn send(
+        self,
+        client: &MangaDexClient,
+    ) -> mangadex_api_schema::v5::MangaReadMarkersResponse {
+        <GetReadChaptersBuilder as From<Self>>::from(self)
+            .http_client(client.get_http_client().clone())
+            .send()
+            .await
+    }
+}

mangadex-api-params-types/src/report.rs

@@ -0,0 +1,3 @@
+pub mod create;
+pub mod list;
+pub mod list_by_category;

mangadex-api-params-types/src/report/create.rs

@@ -0,0 +1,54 @@
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api::{v5::report::post::CreateReportBuilder, MangaDexClient};
+
+use mangadex_api_types::ReportCategory;
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Type, Serialize, Deserialize)]
+pub struct CreateReportParam {
+    pub category: ReportCategory,
+    /// The report reason ID for sub-categorization.
+    ///
+    /// For example, if a manga was being reported for being a troll entry, the specific reason ID should be used, obtained from the [list report reasons endpoint](crate::v5::report::list).
+    pub reason: Uuid,
+    /// The ID from the category type.
+    ///
+    /// For example, if the category is "manga", this should be a manga UUID.
+    pub object_id: Uuid,
+    /// Optional notes about why this is being reported.
+    #[serde(default)]
+    pub details: Option<String>,
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl From<CreateReportParam> for CreateReportBuilder {
+    fn from(value: CreateReportParam) -> Self {
+        let mut builder = Self::default();
+        builder.category(value.category);
+        builder.reason(value.reason);
+        builder.object_id(value.object_id);
+        if let Some(details) = value.details {
+            builder.details(details);
+        }
+        builder
+    }
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl CreateReportParam {
+    pub async fn send(
+        self,
+        client: &MangaDexClient,
+    ) -> mangadex_api_types::error::Result<mangadex_api_schema::Limited<()>> {
+        let res = <CreateReportBuilder as From<Self>>::from(self)
+            .http_client(client.get_http_client().clone())
+            .send()
+            .await?;
+        Ok(mangadex_api_schema::Limited {
+            rate_limit: res.rate_limit,
+            body: (),
+        })
+    }
+}

mangadex-api-params-types/src/report/list.rs

@@ -0,0 +1,67 @@
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api::{v5::report::get::ListReportsByUserBuilder, MangaDexClient};
+
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api_schema::{v5::UserReportsCollection, Limited};
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api_types::error::Result;
+
+use mangadex_api_types::{
+    ReferenceExpansionResource, ReportCategory, ReportSortOrder, ReportStatus,
+};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use uuid::Uuid;
+
+#[derive(Debug, Clone, Type, Serialize, Deserialize, Default)]
+#[serde(default)]
+pub struct ListReportParams {
+    pub limit: Option<u32>,
+    pub offset: Option<u32>,
+    pub category: Option<ReportCategory>,
+    pub object_id: Option<Uuid>,
+    pub reason_id: Option<Uuid>,
+    pub status: Option<ReportStatus>,
+    pub order: Option<ReportSortOrder>,
+    pub includes: Vec<ReferenceExpansionResource>,
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl From<ListReportParams> for ListReportsByUserBuilder {
+    fn from(value: ListReportParams) -> Self {
+        let mut builder = Self::default();
+        if let Some(limit) = value.limit {
+            builder.limit(limit);
+        }
+        if let Some(offset) = value.offset {
+            builder.offset(offset);
+        }
+        if let Some(category) = value.category {
+            builder.category(category);
+        }
+        if let Some(object_id) = value.object_id {
+            builder.object_id(object_id);
+        }
+        if let Some(reason_id) = value.reason_id {
+            builder.reason_id(reason_id);
+        }
+        if let Some(status) = value.status {
+            builder.status(status);
+        }
+        if let Some(order) = value.order {
+            builder.order(order);
+        }
+        builder.includes(value.includes);
+        builder
+    }
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl ListReportParams {
+    pub async fn send(self, client: &MangaDexClient) -> Result<Limited<UserReportsCollection>> {
+        <ListReportsByUserBuilder as From<Self>>::from(self)
+            .http_client(client.get_http_client().clone())
+            .send()
+            .await
+    }
+}

mangadex-api-params-types/src/report/list_by_category.rs

@@ -0,0 +1,33 @@
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api::{v5::report::reasons::category::get::ListReasonsBuilder, MangaDexClient};
+
+use mangadex_api_types::ReportCategory;
+use serde::{Deserialize, Serialize};
+use specta::Type;
+
+#[derive(Debug, Clone, Type, Serialize, Deserialize)]
+pub struct ListReasonsByCategory {
+    pub category: ReportCategory,
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl From<ListReasonsByCategory> for ListReasonsBuilder {
+    fn from(value: ListReasonsByCategory) -> Self {
+        let mut builder = Self::default();
+        builder.category(value.category);
+        builder
+    }
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl ListReasonsByCategory {
+    pub async fn send(
+        self,
+        client: &MangaDexClient,
+    ) -> mangadex_api_schema::v5::ReportReasonListResponse {
+        <ListReasonsBuilder as From<ListReasonsByCategory>>::from(self)
+            .http_client(client.get_http_client().clone())
+            .send()
+            .await
+    }
+}

mangadex-api-params-types/src/scanlation_group.rs

@@ -0,0 +1,4 @@
+pub mod create;
+pub mod edit;
+pub mod get_unique;
+pub mod list;

mangadex-api-params-types/src/scanlation_group/create.rs

@@ -0,0 +1,97 @@
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api::{v5::scanlation_group::post::CreateGroupBuilder, MangaDexClient};
+
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api_schema::{v5::GroupData, Limited};
+#[cfg(feature = "mangadex-api-resolver")]
+use mangadex_api_types::error::Result;
+
+use mangadex_api_types::MangaDexDuration;
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use url::Url;
+
+#[derive(Debug, Clone, Type, Serialize, Deserialize)]
+pub struct CreateScalantionGroupParam {
+    pub name: String,
+    /// Nullable.
+    #[serde(default)]
+    pub website: Option<String>,
+    /// Nullable.
+    #[serde(default)]
+    pub irc_server: Option<String>,
+    /// Nullable.
+    #[serde(default)]
+    pub irc_channel: Option<String>,
+    /// Nullable.
+    #[serde(default)]
+    pub discord: Option<String>,
+    /// Nullable.
+    #[serde(default)]
+    pub contact_email: Option<String>,
+    /// Nullable.
+    #[serde(default)]
+    pub description: Option<String>,
+    /// Nullable.
+    #[serde(default)]
+    pub twitter: Option<Url>,
+    /// Regex: [^https:/\/www\.mangaupdates\.com\/(?:groups|publishers)\.html\?id=\d+](https://www.mangaupdates.com)
+    ///
+    /// Nullable.
+    #[serde(default)]
+    pub manga_updates: Option<Url>,
+    #[serde(default)]
+    pub inactive: Option<bool>,
+    /// Nullable.
+    #[serde(default)]
+    pub publish_delay: Option<MangaDexDuration>,
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl From<CreateScalantionGroupParam> for CreateGroupBuilder {
+    fn from(value: CreateScalantionGroupParam) -> Self {
+        let mut builder = Self::default();
+        builder.name(value.name);
+        if let Some(website) = value.website {
+            builder.website(website);
+        }
+        if let Some(irc_server) = value.irc_server {
+            builder.irc_server(irc_server);
+        }
+        if let Some(irc_channel) = value.irc_channel {
+            builder.irc_channel(irc_channel);
+        }
+        if let Some(discord) = value.discord {
+            builder.discord(discord);
+        }
+        if let Some(contact_email) = value.contact_email {
+            builder.contact_email(contact_email);
+        }
+        if let Some(description) = value.description {
+            builder.description(description);
+        }
+        if let Some(twitter) = value.twitter {
+            builder.twitter(twitter);
+        }
+        if let Some(manga_updates) = value.manga_updates {
+            builder.manga_updates(manga_updates);
+        }
+        if let Some(inactive) = value.inactive {
+            builder.inactive(inactive);
+        }
+        if let Some(publish_delay) = value.publish_delay {
+            builder.publish_delay(publish_delay);
+        }
+        builder
+    }
+}
+
+#[cfg(feature = "mangadex-api-resolver")]
+impl CreateScalantionGroupParam {
+    pub async fn send(self, client: &MangaDexClient) -> Result<Limited<GroupData>> {
+        <CreateGroupBuilder as From<Self>>::from(self)
+            .http_client(client.get_http_client().clone())
+            .send()
+            .await
+    }
+}