VienDesu/core
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

restructure a bit

Browse source
This commit is contained in:
Aleksandr 2025-12-30 00:14:12 +03:00
parent 24b63f1a75
commit b828917b4a
14 changed files with 561 additions and 504 deletions
Download patch file Download diff file Expand all files Collapse all files

14
core/src/errors/files.rs
View file

@ -2,6 +2,20 @@ use eva::data;
use crate::types::file; use crate::types::file;
#[data(display("unexpected file class for this type of operation"), error)]
pub struct UnexpectedFileClass {
pub expected: file::ClassKind,
pub got: file::ClassKind,
}
#[data(error)]
pub enum InvalidImage {
#[display("provided image is too big")]
TooBig,
#[display("provided image is too small")]
TooSmall,
}
#[data(copy, display("file {id} was not found"), error)] #[data(copy, display("file {id} was not found"), error)]
pub struct NotFound { pub struct NotFound {
pub id: file::Id, pub id: file::Id,

8
core/src/requests/games.rs
View file

@ -41,6 +41,10 @@ pub mod update {
NoSuchBadge(#[from] errors::marks::NoSuchBadge), NoSuchBadge(#[from] errors::marks::NoSuchBadge),
#[display("{_0}")] #[display("{_0}")]
NoSuchGenre(#[from] errors::marks::NoSuchGenre), NoSuchGenre(#[from] errors::marks::NoSuchGenre),
#[display("{_0}")]
UnexpectedFileClass(#[from] errors::files::UnexpectedFileClass),
#[display("{_0}")]
InvalidImage(#[from] errors::files::InvalidImage),
} }
} }
@ -169,6 +173,10 @@ pub mod create {
NoSuchTag(#[from] errors::marks::NoSuchTag), NoSuchTag(#[from] errors::marks::NoSuchTag),
#[display("{_0}")] #[display("{_0}")]
NoSuchGenre(#[from] errors::marks::NoSuchGenre), NoSuchGenre(#[from] errors::marks::NoSuchGenre),
#[display("{_0}")]
UnexpectedFileClass(#[from] errors::files::UnexpectedFileClass),
#[display("{_0}")]
InvalidImage(#[from] errors::files::InvalidImage),
} }
} }

4
core/src/requests/uploads.rs
View file

@ -26,8 +26,8 @@ pub mod start {
/// matter. /// matter.
pub name: Option<file::BaseName>, pub name: Option<file::BaseName>,
/// Hash of the file. /// Hash of the file. If specified - verify hashes when finishing.
pub hash: file::Hash, pub hash: Option<file::Hash>,
/// Class of the file. /// Class of the file.
pub class: file::ClassKind, pub class: file::ClassKind,

2
core/src/types/upload.rs
View file

@ -13,5 +13,5 @@ pub struct Upload {
pub uploaded: u64, pub uploaded: u64,
pub size: u64, pub size: u64,
pub class: file::ClassKind, pub class: file::ClassKind,
pub hash: file::Hash, pub expected_hash: Option<file::Hash>,
} }

2
http/src/requests/files.rs
View file

@ -16,4 +16,6 @@ const _: () = {
use status_code::direct; use status_code::direct;
direct!(NotFound => NOT_FOUND); direct!(NotFound => NOT_FOUND);
direct!(InvalidImage => BAD_REQUEST);
direct!(UnexpectedFileClass => BAD_REQUEST);
}; };

18
http/src/requests/games.rs
View file

@ -25,7 +25,14 @@ pub struct Update {
impl_req!(Update => [reqs::update::Ok; reqs::update::Err]); impl_req!(Update => [reqs::update::Ok; reqs::update::Err]);
status_code::direct!(reqs::update::Ok => OK); status_code::direct!(reqs::update::Ok => OK);
status_code::map!(reqs::update::Err => [NotFound, NoSuchBadge, NoSuchGenre, NoSuchTag]); status_code::map!(reqs::update::Err => [
NotFound,
NoSuchBadge,
NoSuchGenre,
NoSuchTag,
UnexpectedFileClass,
InvalidImage,
]);
#[data] #[data]
pub struct Search { pub struct Search {
@ -76,7 +83,14 @@ pub struct Create {
impl_req!(Create => [reqs::create::Ok; reqs::create::Err]); impl_req!(Create => [reqs::create::Ok; reqs::create::Err]);
status_code::direct!(reqs::create::Ok => CREATED); status_code::direct!(reqs::create::Ok => CREATED);
status_code::map!(reqs::create::Err => [AlreadyTaken, NoSuchAuthor, NoSuchGenre, NoSuchTag]); status_code::map!(reqs::create::Err => [
AlreadyTaken,
NoSuchAuthor,
NoSuchGenre,
NoSuchTag,
UnexpectedFileClass,
InvalidImage,
]);
const _: () = { const _: () = {
use errors::games::*; use errors::games::*;

517
http/src/server/routes.rs
View file

@ -11,505 +11,24 @@ use viendesu_core::{
type SessionOf<T> = Session<SessionOfService<<T as Types>::Service>>; type SessionOf<T> = Session<SessionOfService<<T as Types>::Service>>;
mod authors;
mod files;
mod games;
mod marks;
mod uploads;
mod users;
mod forum;
pub fn make<T: Types>(router: RouterScope<T>) -> RouterScope<T> { pub fn make<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router router
.nest("/users", users) .nest("/users", users::make)
.nest("/authors", authors) .nest("/authors", authors::make)
.nest("/games", games) .nest("/games", games::make)
.nest("/boards", boards) .nest("/forum", forum::make)
.nest("/threads", threads) .nest("/uploads", uploads::make)
.nest("/messages", messages) .nest("/files", files::make)
.nest("/uploads", uploads) .nest("/tags", marks::tags)
.nest("/files", files) .nest("/badges", marks::badges)
.nest("/tags", tags) .nest("/genres", marks::genres)
.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,
};
use viendesu_core::{
requests::users::{
begin_auth, check_auth, confirm_sign_up, finish_auth, get, sign_in, sign_up, update,
},
service::{tabs::Tabs, users::Users},
};
fn convert_update(u: Update) -> update::Update {
update::Update {
nickname: u.nickname,
display_name: u.display_name,
bio: u.bio,
password: u.password,
role: u.role,
pfp: u.pfp,
email: u.email,
}
}
router
.route(
"/{sel}",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<Get>| {
let selector: user::Selector = ctx.path().await?;
session
.users()
.get()
.call(get::Args {
user: Some(selector),
})
.await
}),
)
.route(
"/begin-auth",
post(async |mut session: SessionOf<T>, ctx: Ctx<BeginAuth>| {
session
.users()
.begin_auth()
.call(begin_auth::Args {
method: ctx.request.method,
})
.await
}),
)
.route(
"/finish-auth/{authsessid}",
post(
async |mut session: SessionOf<T>, mut ctx: Ctx<FinishAuth>| {
let auth_session: user::AuthSessionId = ctx.path().await?;
session
.users()
.finish_auth()
.call(finish_auth::Args { auth_session })
.await
},
),
)
.route(
"/check-auth",
get(async |mut session: SessionOf<T>, _ctx: Ctx<CheckAuth>| {
session.users().check_auth().call(check_auth::Args {}).await
}),
)
.route(
"/me",
get(async |mut session: SessionOf<T>, _ctx: Ctx<Get>| {
session.users().get().call(get::Args { user: None }).await
}),
)
.route(
"/sign_in",
post(async |mut session: SessionOf<T>, ctx: Ctx<SignIn>| {
session
.users()
.sign_in()
.call(sign_in::Args {
nickname: ctx.request.nickname,
password: ctx.request.password,
})
.await
}),
)
.route(
"/sign_up",
post(async |mut session: SessionOf<T>, ctx: Ctx<SignUp>| {
let SignUp {
nickname,
email,
password,
display_name,
} = ctx.request;
session
.users()
.sign_up()
.call(sign_up::Args {
nickname,
email,
display_name,
password,
})
.await
}),
)
.route(
"/{sel}",
patch(async |mut session: SessionOf<T>, mut ctx: Ctx<Update>| {
let user: user::Selector = ctx.path().await?;
session
.users()
.update()
.call(update::Args {
user: Some(user),
update: convert_update(ctx.request),
})
.await
}),
)
.route(
"/me",
patch(async |mut session: SessionOf<T>, ctx: Ctx<Update>| {
session
.users()
.update()
.call(update::Args {
user: None,
update: convert_update(ctx.request),
})
.await
}),
)
.route(
"/{user}/confirm/{token}",
post(
async |mut session: SessionOf<T>, mut ctx: Ctx<ConfirmSignUp>| {
let (user, token) = ctx.path().await?;
session
.users()
.confirm_sign_up()
.call(confirm_sign_up::Args { user, token })
.await
},
),
)
.nest("/{user}/tabs", |router| {
use crate::requests::tabs::{Delete, Insert, List, ListItems};
use viendesu_core::requests::tabs::{delete, insert, list, list_items};
router
.route(
"/",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<List>| {
let user = ctx.path().await?;
let List {} = ctx.request;
session.tabs().list().call(list::Args { user }).await
}),
)
.nest("/{tab}", |router| {
router
.route(
"/{item}",
delete(async |mut session: SessionOf<T>, mut ctx: Ctx<Delete>| {
let (user, tab, item) = ctx.path().await?;
let Delete {} = ctx.request;
session
.tabs()
.delete()
.call(delete::Args { user, tab, item })
.await
}),
)
.route(
"/",
post(async |mut session: SessionOf<T>, mut ctx: Ctx<Insert>| {
let (user, tab) = ctx.path().await?;
let Insert { item } = ctx.request;
session
.tabs()
.insert()
.call(insert::Args { user, tab, item })
.await
}),
)
.route(
"/",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<ListItems>| {
let (user, tab) = ctx.path().await?;
let ListItems {
resolve_marks,
start_from,
limit,
} = ctx.request;
session
.tabs()
.list_items()
.call(list_items::Args {
tab,
user,
start_from,
limit,
resolve_marks,
})
.await
}),
)
})
})
}
fn uploads<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
}
fn files<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
}
fn authors<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
use crate::requests::authors::{Create, Get, Update};
use viendesu_core::{
requests::authors::{create, get, update},
service::authors::Authors,
types::author,
};
router
.route(
"/",
post(async |mut session: SessionOf<T>, ctx: Ctx<Create>| {
let Create {
title,
slug,
description,
owner,
} = ctx.request;
session
.authors()
.create()
.call(create::Args {
title,
slug,
description,
owner,
})
.await
}),
)
.route(
"/{selector}",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<Get>| {
let author: author::Selector = ctx.path().await?;
let Get {} = ctx.request;
session.authors().get().call(get::Args { author }).await
}),
)
.route(
"/{selector}",
patch(async |mut session: SessionOf<T>, mut ctx: Ctx<Update>| {
let author: author::Selector = ctx.path().await?;
let Update {
title,
description,
pfp,
slug,
verified,
} = ctx.request;
session
.authors()
.update()
.call(update::Args {
author,
update: update::Update {
title,
description,
pfp,
slug,
verified,
},
})
.await
}),
)
}
fn games<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
use crate::requests::games::{Create, Get, Search};
use viendesu_core::{
requests::games::{create, get, search},
service::games::Games,
types::{author, game},
};
router
.route(
"/",
post(async |mut session: SessionOf<T>, ctx: Ctx<Create>| {
let Create {
title,
description,
thumbnail,
tags,
genres,
author,
slug,
vndb,
release_date,
} = ctx.request;
session
.games()
.create()
.call(create::Args {
title,
description,
thumbnail,
author,
slug,
tags,
genres,
vndb,
release_date,
})
.await
}),
)
.route(
"/{game_id}",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<Get>| {
let game_id: game::Id = ctx.path().await?;
let Get { resolve_marks } = ctx.request;
session
.games()
.get()
.call(get::Args {
game: game_id.into(),
resolve_marks,
})
.await
}),
)
.route(
"/{author}/{slug}",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<Get>| {
let (author, slug) = ctx.path::<(author::Selector, game::Slug)>().await?;
let Get { resolve_marks } = ctx.request;
session
.games()
.get()
.call(get::Args {
resolve_marks,
game: game::Selector::FullyQualified(game::FullyQualified { author, slug }),
})
.await
}),
)
.route(
"/search",
post(async |mut session: SessionOf<T>, ctx: Ctx<Search>| {
let Search {
query,
author,
include,
exclude,
order,
sort_by,
limit,
} = ctx.request;
session
.games()
.search()
.call(search::Args {
query,
author,
include,
exclude,
order,
sort_by,
limit,
})
.await
}),
)
}
fn boards<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
}
fn threads<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
}
fn messages<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
} }

71
http/src/server/routes/authors.rs Normal file
View file

@ -0,0 +1,71 @@
use super::*;
use crate::requests::authors::{Create, Get, Update};
use viendesu_core::{
requests::authors::{create, get, update},
service::authors::Authors,
types::author,
};
pub fn make<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
.route(
"/",
post(async |mut session: SessionOf<T>, ctx: Ctx<Create>| {
let Create {
title,
slug,
description,
owner,
} = ctx.request;
session
.authors()
.create()
.call(create::Args {
title,
slug,
description,
owner,
})
.await
}),
)
.route(
"/{selector}",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<Get>| {
let author: author::Selector = ctx.path().await?;
let Get {} = ctx.request;
session.authors().get().call(get::Args { author }).await
}),
)
.route(
"/{selector}",
patch(async |mut session: SessionOf<T>, mut ctx: Ctx<Update>| {
let author: author::Selector = ctx.path().await?;
let Update {
title,
description,
pfp,
slug,
verified,
} = ctx.request;
session
.authors()
.update()
.call(update::Args {
author,
update: update::Update {
title,
description,
pfp,
slug,
verified,
},
})
.await
}),
)
}

5
http/src/server/routes/files.rs Normal file
View file

@ -0,0 +1,5 @@
use super::*;
pub fn make<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
}

20
http/src/server/routes/forum.rs Normal file
View file

@ -0,0 +1,20 @@
use super::*;
pub fn make<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
.nest("/boards", boards)
.nest("/threads", threads)
.nest("/messages", messages)
}
fn boards<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
}
fn threads<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
}
fn messages<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
}

104
http/src/server/routes/games.rs Normal file
View file

@ -0,0 +1,104 @@
use super::*;
use crate::requests::games::{Create, Get, Search};
use viendesu_core::{
requests::games::{create, get, search},
service::games::Games,
types::{author, game},
};
pub fn make<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
.route(
"/",
post(async |mut session: SessionOf<T>, ctx: Ctx<Create>| {
let Create {
title,
description,
thumbnail,
tags,
genres,
author,
slug,
vndb,
release_date,
} = ctx.request;
session
.games()
.create()
.call(create::Args {
title,
description,
thumbnail,
author,
slug,
tags,
genres,
vndb,
release_date,
})
.await
}),
)
.route(
"/{game_id}",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<Get>| {
let game_id: game::Id = ctx.path().await?;
let Get { resolve_marks } = ctx.request;
session
.games()
.get()
.call(get::Args {
game: game_id.into(),
resolve_marks,
})
.await
}),
)
.route(
"/{author}/{slug}",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<Get>| {
let (author, slug) = ctx.path::<(author::Selector, game::Slug)>().await?;
let Get { resolve_marks } = ctx.request;
session
.games()
.get()
.call(get::Args {
resolve_marks,
game: game::Selector::FullyQualified(game::FullyQualified { author, slug }),
})
.await
}),
)
.route(
"/search",
post(async |mut session: SessionOf<T>, ctx: Ctx<Search>| {
let Search {
query,
author,
include,
exclude,
order,
sort_by,
limit,
} = ctx.request;
session
.games()
.search()
.call(search::Args {
query,
author,
include,
exclude,
order,
sort_by,
limit,
})
.await
}),
)
}

78
http/src/server/routes/marks.rs Normal file
View file

@ -0,0 +1,78 @@
use super::*;
pub 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
},
),
)
}
pub 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
}),
)
}
pub 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
}),
)
}

5
http/src/server/routes/uploads.rs Normal file
View file

@ -0,0 +1,5 @@
use super::*;
pub fn make<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
}

217
http/src/server/routes/users.rs Normal file
View file

@ -0,0 +1,217 @@
use super::*;
use crate::requests::users::{
BeginAuth, CheckAuth, ConfirmSignUp, FinishAuth, Get, SignIn, SignUp, Update,
};
use viendesu_core::{
requests::users::{
begin_auth, check_auth, confirm_sign_up, finish_auth, get, sign_in, sign_up, update,
},
service::{tabs::Tabs, users::Users},
};
fn convert_update(u: Update) -> update::Update {
update::Update {
nickname: u.nickname,
display_name: u.display_name,
bio: u.bio,
password: u.password,
role: u.role,
pfp: u.pfp,
email: u.email,
}
}
pub fn make<T: Types>(router: RouterScope<T>) -> RouterScope<T> {
router
.route(
"/{sel}",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<Get>| {
let selector: user::Selector = ctx.path().await?;
session
.users()
.get()
.call(get::Args {
user: Some(selector),
})
.await
}),
)
.route(
"/begin-auth",
post(async |mut session: SessionOf<T>, ctx: Ctx<BeginAuth>| {
session
.users()
.begin_auth()
.call(begin_auth::Args {
method: ctx.request.method,
})
.await
}),
)
.route(
"/finish-auth/{authsessid}",
post(
async |mut session: SessionOf<T>, mut ctx: Ctx<FinishAuth>| {
let auth_session: user::AuthSessionId = ctx.path().await?;
session
.users()
.finish_auth()
.call(finish_auth::Args { auth_session })
.await
},
),
)
.route(
"/check-auth",
get(async |mut session: SessionOf<T>, _ctx: Ctx<CheckAuth>| {
session.users().check_auth().call(check_auth::Args {}).await
}),
)
.route(
"/me",
get(async |mut session: SessionOf<T>, _ctx: Ctx<Get>| {
session.users().get().call(get::Args { user: None }).await
}),
)
.route(
"/sign_in",
post(async |mut session: SessionOf<T>, ctx: Ctx<SignIn>| {
session
.users()
.sign_in()
.call(sign_in::Args {
nickname: ctx.request.nickname,
password: ctx.request.password,
})
.await
}),
)
.route(
"/sign_up",
post(async |mut session: SessionOf<T>, ctx: Ctx<SignUp>| {
let SignUp {
nickname,
email,
password,
display_name,
} = ctx.request;
session
.users()
.sign_up()
.call(sign_up::Args {
nickname,
email,
display_name,
password,
})
.await
}),
)
.route(
"/{sel}",
patch(async |mut session: SessionOf<T>, mut ctx: Ctx<Update>| {
let user: user::Selector = ctx.path().await?;
session
.users()
.update()
.call(update::Args {
user: Some(user),
update: convert_update(ctx.request),
})
.await
}),
)
.route(
"/me",
patch(async |mut session: SessionOf<T>, ctx: Ctx<Update>| {
session
.users()
.update()
.call(update::Args {
user: None,
update: convert_update(ctx.request),
})
.await
}),
)
.route(
"/{user}/confirm/{token}",
post(
async |mut session: SessionOf<T>, mut ctx: Ctx<ConfirmSignUp>| {
let (user, token) = ctx.path().await?;
session
.users()
.confirm_sign_up()
.call(confirm_sign_up::Args { user, token })
.await
},
),
)
.nest("/{user}/tabs", |router| {
use crate::requests::tabs::{Delete, Insert, List, ListItems};
use viendesu_core::requests::tabs::{delete, insert, list, list_items};
router
.route(
"/",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<List>| {
let user = ctx.path().await?;
let List {} = ctx.request;
session.tabs().list().call(list::Args { user }).await
}),
)
.nest("/{tab}", |router| {
router
.route(
"/{item}",
delete(async |mut session: SessionOf<T>, mut ctx: Ctx<Delete>| {
let (user, tab, item) = ctx.path().await?;
let Delete {} = ctx.request;
session
.tabs()
.delete()
.call(delete::Args { user, tab, item })
.await
}),
)
.route(
"/",
post(async |mut session: SessionOf<T>, mut ctx: Ctx<Insert>| {
let (user, tab) = ctx.path().await?;
let Insert { item } = ctx.request;
session
.tabs()
.insert()
.call(insert::Args { user, tab, item })
.await
}),
)
.route(
"/",
get(async |mut session: SessionOf<T>, mut ctx: Ctx<ListItems>| {
let (user, tab) = ctx.path().await?;
let ListItems {
resolve_marks,
start_from,
limit,
} = ctx.request;
session
.tabs()
.list_items()
.call(list_items::Args {
tab,
user,
start_from,
limit,
resolve_marks,
})
.await
}),
)
})
})
}