implement marks

http/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [features]
-default = ["server", "client"]
+default = []
 client = ["dep:reqwest"]
 server = [
     "dep:axum",

http/src/client/marks.rs

@@ -0,0 +1,45 @@
+use super::*;
+
+use crate::requests::marks as requests;
+
+use viendesu_core::requests::marks::{add_badge, add_tag, list_badges, list_genres, list_tags};
+
+impl Genres for HttpClient {
+    fn list(
+        &mut self,
+    ) -> impl CallStep<list_genres::Args, Ok = list_genres::Ok, Err = list_genres::Err> {
+        self.do_call(Method::GET, |list_genres::Args {}| {
+            ("/genres".into(), requests::ListGenres {})
+        })
+    }
+}
+
+impl Tags for HttpClient {
+    fn list(&mut self) -> impl CallStep<list_tags::Args, Ok = list_tags::Ok, Err = list_tags::Err> {
+        self.do_call(Method::GET, |list_tags::Args { query }| {
+            ("/tags".into(), requests::ListTags { query })
+        })
+    }
+
+    fn add(&mut self) -> impl CallStep<add_tag::Args, Ok = add_tag::Ok, Err = add_tag::Err> {
+        self.do_call(Method::POST, |add_tag::Args { tag }| {
+            ("/tags".into(), requests::AddTag { text: tag })
+        })
+    }
+}
+
+impl Badges for HttpClient {
+    fn list(
+        &mut self,
+    ) -> impl CallStep<list_badges::Args, Ok = list_badges::Ok, Err = list_badges::Err> {
+        self.do_call(Method::GET, |list_badges::Args { query }| {
+            ("/badges".into(), requests::ListBadges { query })
+        })
+    }
+
+    fn add(&mut self) -> impl CallStep<add_badge::Args, Ok = add_badge::Ok, Err = add_badge::Err> {
+        self.do_call(Method::POST, |add_badge::Args { badge }| {
+            ("/badges".into(), requests::AddBadge { text: badge })
+        })
+    }
+}

http/src/client/mod.rs

@@ -10,8 +10,15 @@ use viendesu_core::{
     errors::{self, Aux},
     requests::Response,
     service::{
-        CallStep, Session, SessionMaker, authors::Authors, authz::Authentication, boards::Boards,
-        games::Games, messages::Messages, threads::Threads, users::Users,
+        CallStep, Session, SessionMaker,
+        authors::Authors,
+        authz::Authentication,
+        boards::Boards,
+        games::Games,
+        marks::{Badges, Genres, Tags},
+        messages::Messages,
+        threads::Threads,
+        users::Users,
     },
     types::session,
 };
@@ -28,6 +35,8 @@ mod authors;
 mod games;
 mod users;
 
+mod marks;
+
 struct DoRequest<'c, P> {
     client: &'c mut HttpClient,
     method: Method,

http/src/requests/marks.rs

@@ -0,0 +1,48 @@
+use eva::{data, str::CompactString};
+
+use crate::requests::status_code;
+
+use viendesu_core::requests::marks as reqs;
+
+#[data]
+pub struct AddBadge {
+    pub text: CompactString,
+}
+
+impl_req!(AddBadge => [reqs::add_badge::Ok; reqs::add_badge::Err]);
+status_code::direct!(reqs::add_badge::Ok => CREATED);
+status_code::map!(reqs::add_badge::Err => []);
+
+#[data]
+pub struct AddTag {
+    pub text: CompactString,
+}
+
+impl_req!(AddTag => [reqs::add_tag::Ok; reqs::add_tag::Err]);
+status_code::direct!(reqs::add_tag::Ok => CREATED);
+status_code::map!(reqs::add_tag::Err => []);
+
+#[data]
+pub struct ListGenres {}
+
+impl_req!(ListGenres => [reqs::list_genres::Ok; reqs::list_genres::Err]);
+status_code::direct!(reqs::list_genres::Ok => OK);
+status_code::map!(reqs::list_genres::Err => []);
+
+#[data]
+pub struct ListTags {
+    pub query: Option<CompactString>,
+}
+
+impl_req!(ListTags => [reqs::list_tags::Ok; reqs::list_tags::Err]);
+status_code::direct!(reqs::list_tags::Ok => OK);
+status_code::map!(reqs::list_tags::Err => []);
+
+#[data]
+pub struct ListBadges {
+    pub query: Option<CompactString>,
+}
+
+impl_req!(ListBadges => [reqs::list_badges::Ok; reqs::list_badges::Err]);
+status_code::direct!(reqs::list_badges::Ok => OK);
+status_code::map!(reqs::list_badges::Err => []);

http/src/requests/mod.rs

@@ -24,6 +24,7 @@ macro_rules! impl_req {
     };
 }
 
+pub mod marks;
 pub mod users;
 
 pub mod authors;

http/src/server/routes.rs

@@ -21,10 +21,90 @@ pub fn make<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
         .nest("/messages", messages)
         .nest("/uploads", uploads)
         .nest("/files", files)
+        .nest("/tags", tags)
+        .nest("/badges", badges)
+        .nest("/genres", genres)
 }
 
 // == Routes ==
 
+fn genres<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
+    use crate::requests::marks::ListGenres;
+
+    use viendesu_core::{requests::marks::list_genres, service::marks::Genres as _};
+
+    router.route(
+        "/",
+        get(
+            async move |mut session: SessionOf<T>, ctx: Ctx<ListGenres>| {
+                let ListGenres {} = ctx.request;
+
+                session.genres().list().call(list_genres::Args {}).await
+            },
+        ),
+    )
+}
+
+fn badges<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
+    use crate::requests::marks::{AddBadge, ListBadges};
+
+    use viendesu_core::{
+        requests::marks::{add_badge, list_badges},
+        service::marks::Badges as _,
+    };
+
+    router
+        .route(
+            "/",
+            get(
+                async move |mut session: SessionOf<T>, ctx: Ctx<ListBadges>| {
+                    let ListBadges { query } = ctx.request;
+                    session
+                        .badges()
+                        .list()
+                        .call(list_badges::Args { query })
+                        .await
+                },
+            ),
+        )
+        .route(
+            "/",
+            post(async move |mut session: SessionOf<T>, ctx: Ctx<AddBadge>| {
+                let AddBadge { text } = ctx.request;
+                session
+                    .badges()
+                    .add()
+                    .call(add_badge::Args { badge: text })
+                    .await
+            }),
+        )
+}
+
+fn tags<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
+    use crate::requests::marks::{AddTag, ListTags};
+
+    use viendesu_core::{
+        requests::marks::{add_tag, list_tags},
+        service::marks::Tags as _,
+    };
+
+    router
+        .route(
+            "/",
+            get(async move |mut session: SessionOf<T>, ctx: Ctx<ListTags>| {
+                let ListTags { query } = ctx.request;
+                session.tags().list().call(list_tags::Args { query }).await
+            }),
+        )
+        .route(
+            "/",
+            post(async move |mut session: SessionOf<T>, ctx: Ctx<AddTag>| {
+                let AddTag { text } = ctx.request;
+                session.tags().add().call(add_tag::Args { tag: text }).await
+            }),
+        )
+}
+
 fn users<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
     use crate::requests::users::{
         BeginAuth, CheckAuth, ConfirmSignUp, FinishAuth, Get, SignIn, SignUp, Update,