fix: switch to new permissions enum

Cargo.lock

@@ -2163,7 +2163,7 @@ dependencies = [
 [[package]]
 name = "optional_struct"
 version = "0.2.0"
-source = "git+https://github.com/insertish/OptionalStruct?rev=2011de17db6ecb210fddabe3d79ade865efaf4ee#2011de17db6ecb210fddabe3d79ade865efaf4ee"
+source = "git+https://github.com/insertish/OptionalStruct?rev=b57e8e8e77db6e1a7f68c715d0d1760cb64feb0c#b57e8e8e77db6e1a7f68c715d0d1760cb64feb0c"
 dependencies = [
  "quote 0.3.15",
  "syn 0.11.11",

src/routes/bots/invite.rs

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{server_member::MemberCompositeKey, Channel, Member, User},
-    perms, ChannelPermission, Db, EmptyResponse, Error, Ref, Result, ServerPermission,
+    perms, Db, EmptyResponse, Error, Permission, Ref, Result,
 };
 
 use rocket::serde::json::Json;
@@ -34,13 +34,11 @@ pub async fn invite_bot(
             let server = db.fetch_server(&server).await?;
             if !perms(&user)
                 .server(&server)
-                .calc_server(db)
+                .calc(db)
                 .await
-                .get_manage_server()
+                .can_manage_server()
             {
-                return Err(Error::MissingPermission {
-                    permission: ServerPermission::ManageServer as i32,
-                });
+                return Error::from_permission(Permission::ManageServer);
             }
 
             let member = Member {
@@ -57,13 +55,11 @@ pub async fn invite_bot(
             let channel = db.fetch_channel(&group).await?;
             if !perms(&user)
                 .channel(&channel)
-                .calc_channel(db)
+                .calc(db)
                 .await
-                .get_invite_others()
+                .can_invite_others()
             {
-                return Err(Error::MissingPermission {
-                    permission: ChannelPermission::InviteOthers as i32,
-                });
+                return Error::from_permission(Permission::InviteOthers);
             }
 
             if let Channel::Group { id, .. } = channel {

src/routes/channels/channel_ack.rs

@@ -5,9 +5,9 @@ pub async fn req(db: &Db, user: User, target: Ref, message: Ref) -> Result<Empty
     let channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         return Err(Error::NotFound);
     }

src/routes/channels/channel_delete.rs

@@ -1,14 +1,14 @@
 use revolt_quark::{
     models::{channel::PartialChannel, Channel, User},
-    perms, ChannelPermission, Db, EmptyResponse, Error, Ref, Result,
+    perms, Db, EmptyResponse, Error, Permission, Ref, Result,
 };
 
 #[delete("/<target>")]
 pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
     let channel = target.as_channel(db).await?;
-    let perm = perms(&user).channel(&channel).calc_channel(db).await;
+    let perm = perms(&user).channel(&channel).calc(db).await;
 
-    if !perm.get_view() {
+    if !perm.can_view_channel() {
         return Err(Error::NotFound);
     }
 
@@ -30,12 +30,10 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
             .await
             .map(|_| EmptyResponse),
         Channel::TextChannel { .. } | Channel::VoiceChannel { .. } => {
-            if perm.get_manage_channel() {
+            if perm.can_manage_channel() {
                 channel.delete(db).await.map(|_| EmptyResponse)
             } else {
-                Err(Error::MissingPermission {
-                    permission: ChannelPermission::ManageChannel as i32,
-                })
+                Error::from_permission(Permission::ManageChannel)
             }
         }
     }

src/routes/channels/channel_edit.rs

@@ -3,7 +3,7 @@ use revolt_quark::{
         channel::{Channel, FieldsChannel, PartialChannel},
         File, User,
     },
-    perms, ChannelPermission, Database, Error, Ref, Result,
+    perms, Database, Error, Permission, Ref, Result,
 };
 
 use rocket::{serde::json::Json, State};
@@ -40,13 +40,11 @@ pub async fn req(
     let mut channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_manage_channel()
+        .can_manage_channel()
     {
-        return Err(Error::MissingPermission {
-            permission: ChannelPermission::ManageChannel as i32,
-        });
+        return Error::from_permission(Permission::ManageChannel);
     }
 
     if data.name.is_none()

src/routes/channels/channel_fetch.rs

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{Channel, User},
-    perms, ChannelPermission, Database, Error, Ref, Result,
+    perms, Database, Error, Permission, Ref, Result,
 };
 
 use rocket::{serde::json::Json, State};
@@ -11,14 +11,12 @@ pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Json<C
 
     if perms(&user)
         .channel(&target)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         Ok(Json(target))
     } else {
-        Err(Error::MissingPermission {
-            permission: ChannelPermission::View as i32,
-        })
+        Error::from_permission(Permission::ViewChannel)
     }
 }

src/routes/channels/group_add_member.rs

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{Channel, User},
-    perms, ChannelPermission, Db, EmptyResponse, Error, Ref, Result,
+    perms, Db, EmptyResponse, Error, Permission, Ref, Result,
 };
 
 #[put("/<target>/recipients/<member>")]
@@ -8,13 +8,11 @@ pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyR
     let channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_invite_others()
+        .can_invite_others()
     {
-        return Err(Error::MissingPermission {
-            permission: ChannelPermission::InviteOthers as i32,
-        });
+        return Error::from_permission(Permission::InviteOthers);
     }
 
     match &channel {

src/routes/channels/group_remove_member.rs

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{Channel, User},
-    Db, EmptyResponse, Error, Ref, Result,
+    Db, EmptyResponse, Error, Permission, Ref, Result,
 };
 
 #[delete("/<target>/recipients/<member>")]
@@ -12,7 +12,7 @@ pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyR
             owner, recipients, ..
         } => {
             if &user.id != owner {
-                return Err(Error::MissingPermission { permission: 0 });
+                return Error::from_permission(Permission::ManageChannel);
             }
 
             let member = member.as_user(db).await?;

src/routes/channels/invite_create.rs

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{Invite, User},
-    perms, ChannelPermission, Db, Error, Ref, Result,
+    perms, Db, Error, Permission, Ref, Result,
 };
 
 use rocket::serde::json::Json;
@@ -11,13 +11,11 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Invite>> {
 
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_invite_others()
+        .can_invite_others()
     {
-        return Err(Error::MissingPermission {
-            permission: ChannelPermission::InviteOthers as i32,
-        });
+        return Error::from_permission(Permission::InviteOthers);
     }
 
     Invite::create(db, &user, &channel).await.map(Json)

src/routes/channels/members_fetch.rs

@@ -10,9 +10,9 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Vec<User>>> {
     let channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         return Err(Error::NotFound);
     }

src/routes/channels/message_delete.rs

@@ -1,4 +1,4 @@
-use revolt_quark::{models::User, perms, ChannelPermission, Db, EmptyResponse, Error, Ref, Result};
+use revolt_quark::{models::User, perms, Db, EmptyResponse, Error, Permission, Ref, Result};
 
 #[delete("/<target>/messages/<msg>")]
 pub async fn req(db: &Db, user: User, target: Ref, msg: Ref) -> Result<EmptyResponse> {
@@ -11,14 +11,12 @@ pub async fn req(db: &Db, user: User, target: Ref, msg: Ref) -> Result<EmptyResp
         || !{
             perms(&user)
                 .channel(&target.as_channel(db).await?)
-                .calc_channel(db)
+                .calc(db)
                 .await
-                .get_manage_messages()
+                .can_manage_messages()
         }
     {
-        return Err(Error::MissingPermission {
-            permission: ChannelPermission::ManageMessages as i32,
-        });
+        return Error::from_permission(Permission::ManageMessages);
     }
 
     message.delete(db).await.map(|_| EmptyResponse)

src/routes/channels/message_fetch.rs

@@ -10,9 +10,9 @@ pub async fn req(db: &Db, user: User, target: Ref, msg: Ref) -> Result<Json<Mess
     let channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         return Err(Error::NotFound);
     }

src/routes/channels/message_query.rs

@@ -44,9 +44,9 @@ pub async fn req(
     let channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         return Err(Error::NotFound);
     }

src/routes/channels/message_search.rs

@@ -41,9 +41,9 @@ pub async fn req(
     let channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         return Err(Error::NotFound);
     }

src/routes/channels/message_send.rs

@@ -5,7 +5,7 @@ use revolt_quark::{
         message::{Content, Masquerade, Reply, SendableEmbed},
         Message, User,
     },
-    perms, ChannelPermission, Db, Error, Ref, Result,
+    perms, Db, Error, Permission, Ref, Result,
 };
 
 use regex::Regex;
@@ -51,12 +51,10 @@ pub async fn message_send(
     idempotency.consume_nonce(data.nonce).await?;
 
     let channel = target.as_channel(db).await?;
-    let permissions = perms(&user).channel(&channel).calc_channel(db).await;
+    let permissions = perms(&user).channel(&channel).calc(db).await;
 
-    if !permissions.get_send_message() {
-        return Err(Error::MissingPermission {
-            permission: ChannelPermission::SendMessage as i32,
-        });
+    if !permissions.can_send_message() {
+        return Error::from_permission(Permission::SendMessage);
     }
 
     if data.content.is_empty()
@@ -82,10 +80,8 @@ pub async fn message_send(
     }
 
     // 2. Verify permissions for masquerade.
-    if data.masquerade.is_some() && !permissions.get_masquerade() {
-        return Err(Error::MissingPermission {
-            permission: ChannelPermission::Masquerade as i32,
-        });
+    if data.masquerade.is_some() && !permissions.can_masquerade() {
+        return Error::from_permission(Permission::Masquerade);
     }
 
     // 3. Verify replies are valid.
@@ -121,10 +117,8 @@ pub async fn message_send(
     // 4. Add attachments to message.
     let mut attachments = vec![];
     if let Some(ids) = &data.attachments {
-        if !ids.is_empty() && !permissions.get_upload_files() {
-            return Err(Error::MissingPermission {
-                permission: ChannelPermission::UploadFiles as i32,
-            });
+        if !ids.is_empty() && !permissions.can_upload_files() {
+            return Error::from_permission(Permission::UploadFiles);
         }
 
         // ! FIXME: move this to app config

src/routes/channels/permissions_set.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 
 use revolt_quark::{
     models::{Channel, User},
-    perms, ChannelPermission, Db, Error, Ref, Result,
+    perms, Db, Error, Permission, Ref, Result,
 };
 
 #[derive(Serialize, Deserialize)]
@@ -22,15 +22,15 @@ pub async fn req(
     let mut channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_manage_channel()
+        .can_manage_permissions()
     {
-        return Err(Error::MissingPermission {
-            permission: ChannelPermission::ManageChannel as i32,
-        });
+        return Error::from_permission(Permission::ManageChannel);
     }
 
+    // ! FIXME_PERMISSIONS
+
     channel
         .set_role_permission(db, &role, data.permissions)
         .await?;

src/routes/channels/permissions_set_default.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 
 use revolt_quark::{
     models::{channel::PartialChannel, Channel, User},
-    perms, ChannelPermission, Db, Error, Ref, Result,
+    perms, Db, Error, Permission, Ref, Result,
 };
 
 #[derive(Serialize, Deserialize)]
@@ -16,13 +16,11 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<J
     let mut channel = target.as_channel(db).await?;
     if !perms(&user)
         .channel(&channel)
-        .calc_channel(db)
+        .calc(db)
         .await
-        .get_manage_channel()
+        .can_manage_permissions()
     {
-        return Err(Error::MissingPermission {
-            permission: ChannelPermission::ManageChannel as i32,
-        });
+        return Error::from_permission(Permission::ManagePermissions);
     }
 
     match &channel {
@@ -39,6 +37,8 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<J
                 .await?;
         }
         Channel::TextChannel { .. } | Channel::VoiceChannel { .. } => {
+            // ! FIXME_PERMISSIONS
+
             channel
                 .update(
                     db,

src/routes/invites/invite_delete.rs

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{Invite, User},
-    perms, Db, EmptyResponse, Error, Ref, Result, ServerPermission,
+    perms, Db, EmptyResponse, Error, Permission, Ref, Result,
 };
 
 #[delete("/<target>")]
@@ -15,13 +15,11 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
                 let server = db.fetch_server(&server).await?;
                 if !perms(&user)
                     .server(&server)
-                    .calc_server(db)
+                    .calc(db)
                     .await
-                    .get_manage_server()
+                    .can_manage_server()
                 {
-                    return Err(Error::MissingPermission {
-                        permission: ServerPermission::ManageServer as i32,
-                    });
+                    return Error::from_permission(Permission::ManageServer);
                 }
 
                 db.delete_invite(&code).await

src/routes/servers/ban_create.rs

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{ServerBan, User},
-    perms, Db, Error, Ref, Result, ServerPermission,
+    perms, Db, Error, Permission, Ref, Result,
 };
 
 use rocket::serde::json::Json;
@@ -28,17 +28,15 @@ pub async fn req(
     let server = server.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_ban_members()
+        .can_ban_members()
     {
-        return Err(Error::MissingPermission {
-            permission: ServerPermission::BanMembers as i32,
-        });
+        return Error::from_permission(Permission::BanMembers);
     }
 
     let member = target.as_member(db, &server.id).await?;
-    // ! FIXME: calculate permission against member
+    // ! FIXME_PERMISSIONS
 
     let ban = ServerBan {
         id: member.id,

src/routes/servers/ban_list.rs

@@ -1,5 +1,5 @@
 use revolt_quark::models::{File, ServerBan, User};
-use revolt_quark::{perms, Db, Error, Ref, Result, ServerPermission};
+use revolt_quark::{perms, Db, Error, Permission, Ref, Result};
 
 use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
@@ -16,13 +16,11 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Vec<ServerBan>
     let server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_ban_members()
+        .can_ban_members()
     {
-        return Err(Error::MissingPermission {
-            permission: ServerPermission::BanMembers as i32,
-        });
+        return Error::from_permission(Permission::BanMembers);
     }
 
     db.fetch_bans(&server.id).await.map(Json)

src/routes/servers/ban_remove.rs

@@ -1,17 +1,15 @@
-use revolt_quark::{models::User, perms, Db, EmptyResponse, Error, Ref, Result, ServerPermission};
+use revolt_quark::{models::User, perms, Db, EmptyResponse, Error, Permission, Ref, Result};
 
 #[delete("/<server>/bans/<target>")]
 pub async fn req(db: &Db, user: User, server: Ref, target: Ref) -> Result<EmptyResponse> {
     let server = server.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_ban_members()
+        .can_ban_members()
     {
-        return Err(Error::MissingPermission {
-            permission: ServerPermission::BanMembers as i32,
-        });
+        return Error::from_permission(Permission::BanMembers);
     }
 
     let ban = target.as_ban(db, &server.id).await?;

src/routes/servers/channel_create.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use revolt_quark::{
     models::{server::PartialServer, Channel, User},
-    perms, Db, Error, Ref, Result, ServerPermission,
+    perms, Db, Error, Permission, Ref, Result,
 };
 
 use rocket::serde::json::Json;
@@ -43,13 +43,11 @@ pub async fn req(db: &Db, user: User, target: Ref, info: Json<Data>) -> Result<J
     let mut server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_manage_channels()
+        .can_manage_channel()
     {
-        return Err(Error::MissingPermission {
-            permission: ServerPermission::ManageChannels as i32,
-        });
+        return Error::from_permission(Permission::ManageChannel);
     }
 
     let id = Ulid::new().to_string();

src/routes/servers/invites_fetch.rs

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{Invite, User},
-    perms, Db, Error, Ref, Result, ServerPermission,
+    perms, Db, Error, Permission, Ref, Result,
 };
 
 use rocket::serde::json::Json;
@@ -19,13 +19,11 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Vec<Invite>>>
     let server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_manage_server()
+        .can_manage_server()
     {
-        return Err(Error::MissingPermission {
-            permission: ServerPermission::ManageServer as i32,
-        });
+        return Error::from_permission(Permission::ManageServer);
     }
 
     db.fetch_invites_for_server(&server.id).await.map(Json)

src/routes/servers/member_edit.rs

@@ -33,8 +33,8 @@ pub async fn req(
         .map_err(|error| Error::FailedValidation { error })?;
 
     let server = server.as_server(db).await?;
-    let permissions = perms(&user).server(&server).calc_server(db).await;
-    if !permissions.get_view() {
+    let permissions = perms(&user).server(&server).calc(db).await;
+    if !permissions.can_view_channel() {
         return Err(Error::NotFound);
     }
 

src/routes/servers/member_fetch.rs

@@ -9,9 +9,9 @@ pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<Json<M
     let server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         return Err(Error::NotFound);
     }

src/routes/servers/member_fetch_all.rs

@@ -7,9 +7,9 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<Value> {
     let server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         return Err(Error::NotFound);
     }

src/routes/servers/member_remove.rs

@@ -1,21 +1,19 @@
-use revolt_quark::{models::User, perms, Db, EmptyResponse, Error, Ref, Result, ServerPermission};
+use revolt_quark::{models::User, perms, Db, EmptyResponse, Error, Permission, Ref, Result};
 
 #[delete("/<target>/members/<member>")]
 pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyResponse> {
     let server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_kick_members()
+        .can_kick_members()
     {
-        return Err(Error::MissingPermission {
-            permission: ServerPermission::KickMembers as i32,
-        });
+        return Error::from_permission(Permission::KickMembers);
     }
 
     let member = member.as_member(db, &server.id).await?;
-    // ! FIXME: calculate permission against member
+    // ! FIXME_PERMISSIONS
 
     member.delete(db).await.map(|_| EmptyResponse)
 }

src/routes/servers/permissions_set.rs

@@ -28,9 +28,9 @@ pub async fn req(
     let mut server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_manage_roles()
+        .can_manage_permissions()
     {
         return Err(Error::NotFound);
     }

src/routes/servers/permissions_set_default.rs

@@ -24,9 +24,9 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<J
     let mut server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_manage_roles()
+        .can_manage_permissions()
     {
         return Err(Error::NotFound);
     }

src/routes/servers/roles_create.rs

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{server::Role, User},
-    perms, Db, Error, Ref, Result, DEFAULT_PERMISSION_CHANNEL_SERVER, DEFAULT_SERVER_PERMISSION,
+    perms, Db, Error, Ref, Result,
 };
 
 use rocket::serde::json::{Json, Value};
@@ -22,19 +22,16 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<V
     let server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_manage_roles()
+        .can_manage_roles()
     {
         return Err(Error::NotFound);
     }
 
     let role = Role {
         name: data.name,
-        permissions: (
-            *DEFAULT_SERVER_PERMISSION as i32,
-            *DEFAULT_PERMISSION_CHANNEL_SERVER as i32,
-        ),
+        permissions: (0_i32, 0_i32),
         ..Default::default()
     };
 

src/routes/servers/roles_delete.rs

@@ -5,14 +5,14 @@ pub async fn req(db: &Db, user: User, target: Ref, role_id: String) -> Result<Em
     let mut server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_manage_roles()
+        .can_manage_roles()
     {
         return Err(Error::NotFound);
     }
 
-    // ! FIXME: check perms against role
+    // ! FIXME_PERMISSIONS
 
     if let Some(role) = server.roles.remove(&role_id) {
         role.delete(db, &server.id, &role_id)

src/routes/servers/roles_edit.rs

@@ -37,9 +37,9 @@ pub async fn req(
     let mut server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_manage_roles()
+        .can_manage_roles()
     {
         return Err(Error::NotFound);
     }

src/routes/servers/server_ack.rs

@@ -5,9 +5,9 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
     let server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         return Err(Error::NotFound);
     }

src/routes/servers/server_create.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use revolt_quark::{
     models::{server_member::MemberCompositeKey, Channel, Member, Server, User},
-    Db, Error, Result, DEFAULT_PERMISSION_CHANNEL_SERVER, DEFAULT_SERVER_PERMISSION,
+    Db, Error, Result,
 };
 
 use rocket::serde::json::Json;
@@ -66,10 +66,7 @@ pub async fn req(db: &Db, user: User, info: Json<Data>) -> Result<Json<Server>>
         description,
         channels: vec![channel_id],
         nsfw: nsfw.unwrap_or(false),
-        default_permissions: (
-            *DEFAULT_SERVER_PERMISSION as i32,
-            *DEFAULT_PERMISSION_CHANNEL_SERVER as i32,
-        ),
+        default_permissions: (0_i32, 0_i32),
         ..Default::default()
     };
 

src/routes/servers/server_edit.rs

@@ -3,7 +3,7 @@ use revolt_quark::{
         server::{Category, FieldsServer, PartialServer, SystemMessageChannels},
         File, Server, User,
     },
-    perms, Db, Error, Ref, Result, ServerPermission,
+    perms, Db, Error, Permission, Ref, Result,
 };
 
 use rocket::serde::json::Json;
@@ -38,8 +38,8 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<J
         .map_err(|error| Error::FailedValidation { error })?;
 
     let mut server = target.as_server(db).await?;
-    let permissions = perms(&user).server(&server).calc_server(db).await;
-    if !permissions.get_view() {
+    let permissions = perms(&user).server(&server).calc(db).await;
+    if !permissions.can_view_channel() {
         return Err(Error::NotFound);
     }
 
@@ -63,15 +63,11 @@ pub async fn req(db: &Db, user: User, target: Ref, data: Json<Data>) -> Result<J
         || data.nsfw.is_some()
         || data.analytics.is_some()
         || data.remove.is_some())
-        && !permissions.get_manage_server()
+        && !permissions.can_manage_server()
     {
-        return Err(Error::MissingPermission {
-            permission: ServerPermission::ManageServer as i32,
-        });
-    } else if (data.categories.is_some()) && !permissions.get_manage_channels() {
-        return Err(Error::MissingPermission {
-            permission: ServerPermission::ManageChannels as i32,
-        });
+        return Error::from_permission(Permission::ManageServer);
+    } else if (data.categories.is_some()) && !permissions.can_manage_channel() {
+        return Error::from_permission(Permission::ManageChannel);
     }
 
     let Data {

src/routes/servers/server_fetch.rs

@@ -9,9 +9,9 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Server>> {
     let server = target.as_server(db).await?;
     if !perms(&user)
         .server(&server)
-        .calc_server(db)
+        .calc(db)
         .await
-        .get_view()
+        .can_view_channel()
     {
         return Err(Error::NotFound);
     }

src/routes/users/open_dm.rs

@@ -30,6 +30,6 @@ pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Json<C
         new_channel.create(db).await?;
         Ok(Json(new_channel))
     } else {
-        Error::from_permission(UserPermission::SendMessage)
+        Error::from_user_permission(UserPermission::SendMessage)
     }
 }