HMC/handmade-revolt-backend
6
0
Fork 0
forked from jmug/stoatchat
Code Pull Requests Actions Packages Releases 2 Activity

refactor(quark): port roles_create, roles_delete, roles_edit, roles_fetch, server_ack, server_delete, server_edit, server_fetch

Browse Source 
#283
This commit is contained in:
Paul Makles
2024-04-07 22:13:42 +01:00
parent 78fb6e1982
commit 9e42567050
12 changed files with 355 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
crates/core/database/src/models/bots/model.rs
View File

@@ -93,7 +93,7 @@ impl Bot {
Some(id.to_string()),
Some(PartialUser {
bot: Some(BotInformation {
owner: id.to_string(),
owner: owner.id.to_string(),
}),
..Default::default()
}),

41
crates/core/database/src/util/bridge/v0.rs
View File

@@ -587,6 +587,18 @@ impl From<crate::FieldsServer> for FieldsServer {
}
}
impl From<FieldsServer> for crate::FieldsServer {
fn from(value: FieldsServer) -> crate::FieldsServer {
match value {
FieldsServer::Banner => crate::FieldsServer::Banner,
FieldsServer::Categories => crate::FieldsServer::Categories,
FieldsServer::Description => crate::FieldsServer::Description,
FieldsServer::Icon => crate::FieldsServer::Icon,
FieldsServer::SystemMessages => crate::FieldsServer::SystemMessages,
}
}
}
impl From<crate::Category> for Category {
fn from(value: crate::Category) -> Self {
Category {
@@ -597,6 +609,16 @@ impl From<crate::Category> for Category {
}
}
impl From<Category> for crate::Category {
fn from(value: Category) -> Self {
crate::Category {
id: value.id,
title: value.title,
channels: value.channels,
}
}
}
impl From<crate::SystemMessageChannels> for SystemMessageChannels {
fn from(value: crate::SystemMessageChannels) -> Self {
SystemMessageChannels {
@@ -608,6 +630,17 @@ impl From<crate::SystemMessageChannels> for SystemMessageChannels {
}
}
impl From<SystemMessageChannels> for crate::SystemMessageChannels {
fn from(value: SystemMessageChannels) -> Self {
crate::SystemMessageChannels {
user_joined: value.user_joined,
user_left: value.user_left,
user_kicked: value.user_kicked,
user_banned: value.user_banned,
}
}
}
impl From<crate::Role> for Role {
fn from(value: crate::Role) -> Self {
Role {
@@ -640,6 +673,14 @@ impl From<crate::FieldsRole> for FieldsRole {
}
}
impl From<FieldsRole> for crate::FieldsRole {
fn from(value: FieldsRole) -> Self {
match value {
FieldsRole::Colour => crate::FieldsRole::Colour,
}
}
}
impl crate::User {
pub async fn into<'a, P>(self, db: &Database, perspective: P) -> User
where

123
crates/core/models/src/v0/servers.rs
View File

@@ -1,4 +1,4 @@
use super::{Channel, File};
use super::{Channel, File, RE_COLOUR};
use revolt_permissions::{Override, OverrideField};
use std::collections::HashMap;
@@ -6,6 +6,9 @@ use std::collections::HashMap;
#[cfg(feature = "validator")]
use validator::Validate;
#[cfg(feature = "rocket")]
use rocket::FromForm;
auto_derived_partial!(
/// Server
pub struct Server {
@@ -120,10 +123,13 @@ auto_derived!(
}
/// Channel category
#[cfg_attr(feature = "validator", derive(Validate))]
pub struct Category {
/// Unique ID for this category
#[cfg_attr(feature = "validator", validate(length(min = 1, max = 32)))]
pub id: String,
/// Title for this category
#[cfg_attr(feature = "validator", validate(length(min = 1, max = 32)))]
pub title: String,
/// Channels in this category
pub channels: Vec<String>,
@@ -160,10 +166,24 @@ auto_derived!(
pub nsfw: Option<bool>,
}
/// New role permissions
pub struct DataSetServerRolePermission {
/// Allow / deny values for the role in this server.
pub permissions: Override,
/// Information about new role to create
#[cfg_attr(feature = "validator", derive(Validate))]
pub struct DataCreateRole {
/// Role name
#[cfg_attr(feature = "validator", validate(length(min = 1, max = 32)))]
pub name: String,
/// Ranking position
///
/// Smaller values take priority.
pub rank: Option<i64>,
}
/// Response after creating new role
pub struct NewRoleResponse {
/// Id of the role
pub id: String,
/// New role
pub role: Role,
}
/// Information returned when creating server
@@ -173,4 +193,97 @@ auto_derived!(
/// Default channels
pub channels: Vec<Channel>,
}
/// Options when fetching server
#[cfg_attr(feature = "rocket", derive(FromForm))]
pub struct OptionsFetchServer {
/// Whether to include channels
pub include_channels: Option<bool>,
}
/// Fetch server information
#[serde(untagged)]
pub enum FetchServerResponse {
JustServer(Server),
ServerWithChannels {
#[serde(flatten)]
server: Server,
channels: Vec<Channel>,
},
}
/// New server information
#[cfg_attr(feature = "validator", derive(Validate))]
pub struct DataEditServer {
/// Server name
#[cfg_attr(feature = "validator", validate(length(min = 1, max = 32)))]
pub name: Option<String>,
/// Server description
#[cfg_attr(feature = "validator", validate(length(min = 0, max = 1024)))]
pub description: Option<String>,
/// Attachment Id for icon
pub icon: Option<String>,
/// Attachment Id for banner
pub banner: Option<String>,
/// Category structure for server
#[cfg_attr(feature = "validator", validate)]
pub categories: Option<Vec<Category>>,
/// System message configuration
pub system_messages: Option<SystemMessageChannels>,
/// Bitfield of server flags
#[cfg_attr(feature = "validator", serde(skip_serializing_if = "Option::is_none"))]
pub flags: Option<i32>,
// Whether this server is age-restricted
// nsfw: Option<bool>,
/// Whether this server is public and should show up on [Revolt Discover](https://rvlt.gg)
pub discoverable: Option<bool>,
/// Whether analytics should be collected for this server
///
/// Must be enabled in order to show up on [Revolt Discover](https://rvlt.gg).
pub analytics: Option<bool>,
/// Fields to remove from server object
#[cfg_attr(feature = "validator", validate(length(min = 1)))]
pub remove: Option<Vec<FieldsServer>>,
}
/// New role information
#[cfg_attr(feature = "validator", derive(Validate))]
pub struct DataEditRole {
/// Role name
#[cfg_attr(feature = "validator", validate(length(min = 1, max = 32)))]
pub name: Option<String>,
/// Role colour
#[cfg_attr(
feature = "validator",
validate(length(min = 1, max = 128), regex = "RE_COLOUR")
)]
pub colour: Option<String>,
/// Whether this role should be displayed separately
pub hoist: Option<bool>,
/// Ranking position
///
/// Smaller values take priority.
pub rank: Option<i64>,
/// Fields to remove from role object
#[cfg_attr(feature = "validator", validate(length(min = 1)))]
pub remove: Option<Vec<FieldsRole>>,
}
/// New role permissions
pub struct DataSetServerRolePermission {
/// Allow / deny values for the role in this server.
pub permissions: Override,
}
/// Options when leaving a server
#[cfg_attr(feature = "rocket", derive(FromForm))]
pub struct OptionsServerDelete {
/// Whether to not send a leave message
pub leave_silently: Option<bool>,
}
);

16
crates/delta/src/routes/servers/mod.rs
View File

@@ -27,10 +27,10 @@ mod server_fetch;
pub fn routes() -> (Vec<Route>, OpenApi) {
openapi_get_routes_spec![
server_create::create_server,
server_delete::req,
server_fetch::req,
server_edit::req,
server_ack::req,
server_delete::delete,
server_fetch::fetch,
server_edit::edit,
server_ack::ack,
channel_create::create_server_channel,
member_fetch_all::fetch_all,
member_remove::kick,
@@ -41,10 +41,10 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
ban_remove::unban,
ban_list::list,
invites_fetch::invites,
roles_create::req,
roles_edit::req,
roles_fetch::req,
roles_delete::req,
roles_create::create,
roles_edit::edit,
roles_fetch::fetch,
roles_delete::delete,
permissions_set::set_role_permission,
permissions_set_default::set_default_permissions,
emoji_list::list_emoji

80
crates/delta/src/routes/servers/roles_create.rs
View File

@@ -1,63 +1,49 @@
use revolt_quark::{
models::{server::Role, User},
perms, Db, Error, Permission, Ref, Result, variables::delta::MAX_ROLE_COUNT,
use revolt_config::config;
use revolt_database::{
util::{permissions::DatabasePermissionQuery, reference::Reference},
Database, Role, User,
};
use rocket::serde::json::Json;
use serde::{Deserialize, Serialize};
use revolt_models::v0;
use revolt_permissions::{calculate_server_permissions, ChannelPermission};
use revolt_result::{create_error, Result};
use rocket::{serde::json::Json, State};
use validator::Validate;
/// # Role Data
#[derive(Validate, Deserialize, JsonSchema)]
pub struct DataCreateRole {
/// Role name
#[validate(length(min = 1, max = 32))]
name: String,
/// Ranking position
///
/// Smaller values take priority.
rank: Option<i64>,
}
/// # New Role Response
#[derive(Serialize, JsonSchema)]
pub struct NewRoleResponse {
/// Id of the role
id: String,
/// New role
role: Role,
}
/// # Create Role
///
/// Creates a new server role.
#[openapi(tag = "Server Permissions")]
#[post("/<target>/roles", data = "<data>")]
pub async fn req(
db: &Db,
pub async fn create(
db: &State<Database>,
user: User,
target: Ref,
data: Json<DataCreateRole>,
) -> Result<Json<NewRoleResponse>> {
target: Reference,
data: Json<v0::DataCreateRole>,
) -> Result<Json<v0::NewRoleResponse>> {
let data = data.into_inner();
data.validate()
.map_err(|error| Error::FailedValidation { error })?;
data.validate().map_err(|error| {
create_error!(FailedValidation {
error: error.to_string()
})
})?;
let server = target.as_server(db).await?;
let mut permissions = perms(&user).server(&server);
let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
calculate_server_permissions(&mut query)
.await
.throw_if_lacking_channel_permission(ChannelPermission::ManageRole);
permissions
.throw_permission(db, Permission::ManageRole)
.await?;
if server.roles.len() > *MAX_ROLE_COUNT {
return Err(Error::TooManyRoles { max: *MAX_ROLE_COUNT })
let config = config().await;
if server.roles.len() >= config.features.limits.default.server_roles {
return Err(create_error!(TooManyRoles {
max: config.features.limits.default.server_roles,
}));
};
let member_rank = permissions.get_member_rank();
let member_rank = query.get_member_rank();
let rank = if let Some(given_rank) = data.rank {
if given_rank <= member_rank.unwrap_or(i64::MIN) {
return Err(Error::NotElevated);
return Err(create_error!(NotElevated));
}
given_rank
@@ -68,11 +54,13 @@ pub async fn req(
let role = Role {
name: data.name,
rank,
..Default::default()
colour: None,
hoist: false,
permissions: Default::default(),
};
Ok(Json(NewRoleResponse {
Ok(Json(v0::NewRoleResponse {
id: role.create(db, &server.id).await?,
role,
role: role.into(),
}))
}

31
crates/delta/src/routes/servers/roles_delete.rs
View File

@@ -1,29 +1,40 @@
use revolt_quark::{models::User, perms, Db, EmptyResponse, Error, Permission, Ref, Result};
use revolt_database::{
util::{permissions::DatabasePermissionQuery, reference::Reference},
Database, User,
};
use revolt_permissions::{calculate_server_permissions, ChannelPermission};
use revolt_result::{create_error, Result};
use rocket::State;
use rocket_empty::EmptyResponse;
/// # Delete Role
///
/// Delete a server role by its id.
#[openapi(tag = "Server Permissions")]
#[delete("/<target>/roles/<role_id>")]
pub async fn req(db: &Db, user: User, target: Ref, role_id: String) -> Result<EmptyResponse> {
pub async fn delete(
db: &State<Database>,
user: User,
target: Reference,
role_id: String,
) -> Result<EmptyResponse> {
let mut server = target.as_server(db).await?;
let mut permissions = perms(&user).server(&server);
let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
calculate_server_permissions(&mut query)
.await
.throw_if_lacking_channel_permission(ChannelPermission::ManageRole);
permissions
.throw_permission(db, Permission::ManageRole)
.await?;
let member_rank = permissions.get_member_rank().unwrap_or(i64::MIN);
let member_rank = query.get_member_rank().unwrap_or(i64::MIN);
if let Some(role) = server.roles.remove(&role_id) {
if role.rank <= member_rank {
return Err(Error::NotElevated);
return Err(create_error!(NotElevated));
}
role.delete(db, &server.id, &role_id)
.await
.map(|_| EmptyResponse)
} else {
Err(Error::NotFound)
Err(create_error!(NotFound))
}
}

79
crates/delta/src/routes/servers/roles_edit.rs
View File

@@ -1,69 +1,48 @@
use revolt_quark::{
models::{
server::{FieldsRole, PartialRole, Role},
User,
},
perms,
util::regex::RE_COLOUR,
Db, Error, Permission, Ref, Result,
use revolt_database::{
util::{permissions::DatabasePermissionQuery, reference::Reference},
Database, PartialRole, User,
};
use rocket::serde::json::Json;
use revolt_models::v0;
use revolt_permissions::{calculate_server_permissions, ChannelPermission};
use revolt_result::{create_error, Result};
use rocket::{serde::json::Json, State};
use serde::{Deserialize, Serialize};
use validator::Validate;
/// # Role Data
#[derive(Validate, Serialize, Deserialize, JsonSchema)]
pub struct DataEditRole {
/// Role name
#[validate(length(min = 1, max = 32))]
name: Option<String>,
/// Role colour
#[validate(length(min = 1, max = 128), regex = "RE_COLOUR")]
colour: Option<String>,
/// Whether this role should be displayed separately
hoist: Option<bool>,
/// Ranking position
///
/// Smaller values take priority.
rank: Option<i64>,
/// Fields to remove from role object
#[validate(length(min = 1))]
remove: Option<Vec<FieldsRole>>,
}
/// # Edit Role
///
/// Edit a role by its id.
#[openapi(tag = "Server Permissions")]
#[patch("/<target>/roles/<role_id>", data = "<data>")]
pub async fn req(
db: &Db,
pub async fn edit(
db: &State<Database>,
user: User,
target: Ref,
target: Reference,
role_id: String,
data: Json<DataEditRole>,
) -> Result<Json<Role>> {
data: Json<v0::DataEditRole>,
) -> Result<Json<v0::Role>> {
let data = data.into_inner();
data.validate()
.map_err(|error| Error::FailedValidation { error })?;
data.validate().map_err(|error| {
create_error!(FailedValidation {
error: error.to_string()
})
})?;
let mut server = target.as_server(db).await?;
let mut permissions = perms(&user).server(&server);
let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
calculate_server_permissions(&mut query)
.await
.throw_if_lacking_channel_permission(ChannelPermission::ManageRole);
permissions
.throw_permission(db, Permission::ManageRole)
.await?;
let member_rank = permissions.get_member_rank().unwrap_or(i64::MIN);
let member_rank = query.get_member_rank().unwrap_or(i64::MIN);
if let Some(mut role) = server.roles.remove(&role_id) {
// Prevent us from editing roles above us
if role.rank <= member_rank {
return Err(Error::NotElevated);
return Err(create_error!(NotElevated));
}
let DataEditRole {
let v0::DataEditRole {
name,
colour,
hoist,
@@ -74,7 +53,7 @@ pub async fn req(
// Prevent us from moving a role above other roles
if let Some(rank) = &rank {
if rank <= &member_rank {
return Err(Error::NotElevated);
return Err(create_error!(NotElevated));
}
}
@@ -91,12 +70,14 @@ pub async fn req(
&server.id,
&role_id,
partial,
remove.unwrap_or_default(),
remove
.map(|v| v.into_iter().map(Into::into).collect())
.unwrap_or_default(),
)
.await?;
Ok(Json(role))
Ok(Json(role.into()))
} else {
Err(Error::NotFound)
Err(create_error!(NotFound))
}
}

21
crates/delta/src/routes/servers/roles_fetch.rs
View File

@@ -1,19 +1,24 @@
use revolt_quark::{models::server::Role, Db, Error, Ref, Result};
use rocket::serde::json::Json;
use revolt_database::{util::reference::Reference, Database};
use revolt_models::v0;
use revolt_result::{create_error, Result};
use rocket::{serde::json::Json, State};
/// # Fetch Role
///
/// Fetch a role by its id.
#[openapi(tag = "Server Permissions")]
#[get("/<target>/roles/<role_id>")]
pub async fn req(db: &Db, target: Ref, role_id: String) -> Result<Json<Role>> {
let server = target.as_server(db).await?;
let role = server.roles.get(&role_id);
pub async fn fetch(
db: &State<Database>,
target: Reference,
role_id: String,
) -> Result<Json<v0::Role>> {
let mut server = target.as_server(db).await?;
let role = server.roles.remove(&role_id);
if let Some(role) = role {
Ok(Json(role.clone()))
Ok(Json(role.into()))
} else {
Err(Error::NotFound)
Err(create_error!(NotFound))
}
}

18
crates/delta/src/routes/servers/server_ack.rs
View File

@@ -1,17 +1,27 @@
use revolt_quark::{models::User, perms, Db, EmptyResponse, Error, Ref, Result};
use revolt_database::{
util::{permissions::DatabasePermissionQuery, reference::Reference},
Database, User,
};
use revolt_permissions::PermissionQuery;
use revolt_result::{create_error, Result};
use rocket::State;
use rocket_empty::EmptyResponse;
/// # Mark Server As Read
///
/// Mark all channels in a server as read.
#[openapi(tag = "Server Information")]
#[put("/<target>/ack")]
pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
pub async fn ack(db: &State<Database>, user: User, target: Reference) -> Result<EmptyResponse> {
if user.bot.is_some() {
return Err(Error::IsBot);
return Err(create_error!(IsBot));
}
let server = target.as_server(db).await?;
perms(&user).server(&server).calc(db).await?;
let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
if !query.are_we_a_member().await {
return Err(create_error!(NotFound));
}
db.acknowledge_channels(&user.id, &server.channels)
.await

31
crates/delta/src/routes/servers/server_delete.rs
View File

@@ -1,27 +1,20 @@
use revolt_quark::{
models::{server_member::RemovalIntention, User},
Db, EmptyResponse, Ref, Result,
};
use serde::{Deserialize, Serialize};
use validator::Validate;
use revolt_database::{util::reference::Reference, Database, RemovalIntention, User};
use revolt_models::v0;
use revolt_result::Result;
use rocket::State;
/// # Query Parameters
#[derive(Validate, Serialize, Deserialize, JsonSchema, FromForm)]
pub struct OptionsServerDelete {
/// Whether to not send a leave message
leave_silently: Option<bool>,
}
use rocket_empty::EmptyResponse;
/// # Delete / Leave Server
///
/// Deletes a server if owner otherwise leaves.
#[openapi(tag = "Server Information")]
#[delete("/<target>?<options..>")]
pub async fn req(
db: &Db,
pub async fn delete(
db: &State<Database>,
user: User,
target: Ref,
options: OptionsServerDelete,
target: Reference,
options: v0::OptionsServerDelete,
) -> Result<EmptyResponse> {
let server = target.as_server(db).await?;
let member = db.fetch_member(&target.id, &user.id).await?;
@@ -29,10 +22,10 @@ pub async fn req(
if server.owner == user.id {
server.delete(db).await
} else {
server
.remove_member(
member
.remove(
db,
member,
&server,
RemovalIntention::Leave,
options.leave_silently.unwrap_or_default(),
)

112
crates/delta/src/routes/servers/server_edit.rs
View File

@@ -1,74 +1,36 @@
use std::collections::HashSet;
use revolt_quark::{
models::{
server::{Category, FieldsServer, PartialServer, SystemMessageChannels},
File, Server, User,
},
perms, Db, Error, Permission, Ref, Result,
use revolt_database::{
util::{permissions::DatabasePermissionQuery, reference::Reference},
Database, File, PartialServer, User,
};
use rocket::serde::json::Json;
use serde::{Deserialize, Serialize};
use revolt_models::v0;
use revolt_permissions::{calculate_server_permissions, ChannelPermission};
use revolt_result::{create_error, Result};
use rocket::{serde::json::Json, State};
use validator::Validate;
/// # Server Data
#[derive(Validate, Serialize, Deserialize, JsonSchema)]
pub struct DataEditServer {
/// Server name
#[validate(length(min = 1, max = 32))]
name: Option<String>,
/// Server description
#[validate(length(min = 0, max = 1024))]
description: Option<String>,
/// Attachment Id for icon
icon: Option<String>,
/// Attachment Id for banner
banner: Option<String>,
/// Category structure for server
#[validate]
categories: Option<Vec<Category>>,
/// System message configuration
system_messages: Option<SystemMessageChannels>,
/// Bitfield of server flags
#[serde(skip_serializing_if = "Option::is_none")]
pub flags: Option<i32>,
// Whether this server is age-restricted
// nsfw: Option<bool>,
/// Whether this server is public and should show up on [Revolt Discover](https://rvlt.gg)
discoverable: Option<bool>,
/// Whether analytics should be collected for this server
///
/// Must be enabled in order to show up on [Revolt Discover](https://rvlt.gg).
analytics: Option<bool>,
/// Fields to remove from server object
#[validate(length(min = 1))]
remove: Option<Vec<FieldsServer>>,
}
/// # Edit Server
///
/// Edit a server by its id.
#[openapi(tag = "Server Information")]
#[patch("/<target>", data = "<data>")]
pub async fn req(
db: &Db,
pub async fn edit(
db: &State<Database>,
user: User,
target: Ref,
data: Json<DataEditServer>,
) -> Result<Json<Server>> {
target: Reference,
data: Json<v0::DataEditServer>,
) -> Result<Json<v0::Server>> {
let data = data.into_inner();
data.validate()
.map_err(|error| Error::FailedValidation { error })?;
data.validate().map_err(|error| {
create_error!(FailedValidation {
error: error.to_string()
})
})?;
let mut server = target.as_server(db).await?;
let mut permissions = perms(&user).server(&server);
permissions.calc(db).await?;
let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
let permissions = calculate_server_permissions(&mut query).await;
// Check permissions
if data.name.is_none()
@@ -83,7 +45,7 @@ pub async fn req(
&& data.discoverable.is_none()
&& data.remove.is_none()
{
return Ok(Json(server));
return Ok(Json(server.into()));
} else if data.name.is_some()
|| data.description.is_some()
|| data.icon.is_some()
@@ -92,26 +54,22 @@ pub async fn req(
|| data.analytics.is_some()
|| data.remove.is_some()
{
permissions
.throw_permission(db, Permission::ManageServer)
.await?;
permissions.throw_if_lacking_channel_permission(ChannelPermission::ManageServer)?;
}
// Check we are privileged if changing sensitive fields
if (data.flags.is_some() /*|| data.nsfw.is_some()*/ || data.discoverable.is_some())
&& !user.privileged
{
return Err(Error::NotPrivileged);
return Err(create_error!(NotPrivileged));
}
// Changing categories requires manage channel
if data.categories.is_some() {
permissions
.throw_permission(db, Permission::ManageChannel)
.await?;
permissions.throw_if_lacking_channel_permission(ChannelPermission::ManageChannel)?;
}
let DataEditServer {
let v0::DataEditServer {
name,
description,
icon,
@@ -128,8 +86,8 @@ pub async fn req(
let mut partial = PartialServer {
name,
description,
categories,
system_messages,
categories: categories.map(|v| v.into_iter().map(Into::into).collect()),
system_messages: system_messages.map(Into::into),
flags,
// nsfw,
discoverable,
@@ -139,13 +97,13 @@ pub async fn req(
// 1. Remove fields from object
if let Some(fields) = &remove {
if fields.contains(&FieldsServer::Banner) {
if fields.contains(&v0::FieldsServer::Banner) {
if let Some(banner) = &server.banner {
db.mark_attachment_as_deleted(&banner.id).await?;
}
}
if fields.contains(&FieldsServer::Icon) {
if fields.contains(&v0::FieldsServer::Icon) {
if let Some(icon) = &server.icon {
db.mark_attachment_as_deleted(&icon.id).await?;
}
@@ -156,7 +114,7 @@ pub async fn req(
if let Some(system_messages) = &partial.system_messages {
for id in system_messages.clone().into_channel_ids() {
if !server.channels.contains(&id) {
return Err(Error::NotFound);
return Err(create_error!(NotFound));
}
}
}
@@ -166,7 +124,7 @@ pub async fn req(
for category in categories {
for channel in &category.channels {
if channel_ids.contains(channel) {
return Err(Error::InvalidOperation);
return Err(create_error!(InvalidOperation));
}
channel_ids.insert(channel.to_string());
@@ -191,8 +149,14 @@ pub async fn req(
}
server
.update(db, partial, remove.unwrap_or_default())
.update(
db,
partial,
remove
.map(|v| v.into_iter().map(Into::into).collect())
.unwrap_or_default(),
)
.await?;
Ok(Json(server))
Ok(Json(server.into()))
}

67
crates/delta/src/routes/servers/server_fetch.rs
View File

@@ -1,65 +1,48 @@
use revolt_quark::{
models::{Channel, Server, User},
perms, Db, Ref, Result,
use revolt_database::{
util::{permissions::DatabasePermissionQuery, reference::Reference},
Database, User,
};
use rocket::serde::json::Json;
use serde::{Deserialize, Serialize};
/// # Query Parameters
#[derive(Deserialize, JsonSchema, FromForm)]
pub struct OptionsFetchServer {
/// Whether to include channels
include_channels: Option<bool>,
}
/// # Fetch server route response
#[derive(Serialize, JsonSchema)]
#[serde(untagged)]
pub enum FetchServerResponse {
JustServer(Server),
ServerWithChannels {
#[serde(flatten)]
server: Server,
channels: Vec<Channel>,
},
}
use revolt_models::v0;
use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionQuery};
use revolt_result::{create_error, Result};
use rocket::{serde::json::Json, State};
/// # Fetch Server
///
/// Fetch a server by its id.
#[openapi(tag = "Server Information")]
#[get("/<target>?<options..>")]
pub async fn req(
db: &Db,
pub async fn fetch(
db: &State<Database>,
user: User,
target: Ref,
options: OptionsFetchServer,
) -> Result<Json<FetchServerResponse>> {
target: Reference,
options: v0::OptionsFetchServer,
) -> Result<Json<v0::FetchServerResponse>> {
let server = target.as_server(db).await?;
let mut perms = perms(&user).server(&server);
perms.calc(db).await?;
let mut query = DatabasePermissionQuery::new(db, &user).server(&server);
if !query.are_we_a_member().await {
return Err(create_error!(NotFound));
}
if let Some(true) = options.include_channels {
let all_channels = db.fetch_channels(&server.channels).await?;
let mut visible_channels = vec![];
let mut visible_channels: Vec<v0::Channel> = vec![];
for channel in all_channels {
if perms
.clone()
.channel(&channel)
.calc(db)
.await?
.can_view_channel()
let mut channel_query = query.clone().channel(&channel);
if calculate_channel_permissions(&mut channel_query)
.await
.has_channel_permission(ChannelPermission::ViewChannel)
{
visible_channels.push(channel);
visible_channels.push(channel.into());
}
}
Ok(Json(FetchServerResponse::ServerWithChannels {
server,
Ok(Json(v0::FetchServerResponse::ServerWithChannels {
server: server.into(),
channels: visible_channels,
}))
} else {
Ok(Json(FetchServerResponse::JustServer(server)))
Ok(Json(v0::FetchServerResponse::JustServer(server.into())))
}
}