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

#283

crates/delta/src/routes/servers/roles_create.rs

@@ -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(),
     }))
 }