perf: code cleanup

src/gateway/events/authenticate.rs

@@ -1,4 +1,3 @@
-use crate::database::pool;
 use crate::gateway::{
     client::Client,
     payload::{ClientPayload, Payload},
@@ -38,26 +37,21 @@ pub async fn run(client: &Client, payload: ClientPayload) {
         .unwrap()
         .into_iter()
         .map(|mut u| {
+            subscriptions.push(user.id);
             u.relationship = user.relations.0.get(&u.id).copied();
             u
         })
         .collect();
 
     if !servers.is_empty() {
-        let server_ids: Vec<i64> = servers.iter().map(|s| s.id).collect();
-
-        let mut other_channels = Channel::select()
+        let mut servers_channels = Channel::select()
             .filter("server_id = ANY($1)")
-            .bind(server_ids)
+            .bind(servers.iter().map(|s| s.id).collect::<Vec<i64>>())
             .fetch_all(pool())
             .await
             .unwrap();
 
-        channels.append(&mut other_channels);
-    }
-
-    for user in &users {
-        subscriptions.push(user.id);
+        channels.append(&mut servers_channels);
     }
 
     for server in &servers {

src/routes/auth/accounts/verify.rs

@@ -5,7 +5,7 @@ use crate::utils::*;
 
 #[derive(Deserialize)]
 pub struct VerifyQuery {
-    user_id: u64,
+    user_id: i64,
     code: String,
 }
 

src/routes/channels/edit.rs

@@ -20,9 +20,9 @@ pub async fn edit(
 ) -> Result<Json<Channel>> {
     let mut group = id.channel(user.id.into()).await?;
 
-    Permissions::fetch(&user, None, group.id.into())
+    Permissions::fetch_cached(&user, None, Some(&group))
         .await?
-        .has(&[Permissions::MANAGE_CHANNELS])?;
+        .has(bits![MANAGE_CHANNELS])?;
 
     group.merge(data);
 

src/routes/channels/kick.rs

@@ -12,7 +12,7 @@ pub async fn kick(
 
     Permissions::fetch_cached(&user, None, Some(&group))
         .await?
-        .has(&[Permissions::KICK_MEMBERS])?;
+        .has(bits![KICK_MEMBERS])?;
 
     if let Some(recipients) = group.recipients.as_mut() {
         let exists = recipients

src/routes/invites/create.rs

@@ -6,18 +6,23 @@ use validator::Validate;
 
 #[derive(Deserialize, Validate, OpgModel)]
 pub struct CreateInviteOptions {
-    channel_id: u64,
+    channel_id: i64,
 }
 
 pub async fn create(
     Extension(user): Extension<User>,
     ValidatedJson(data): ValidatedJson<CreateInviteOptions>,
 ) -> Result<Json<Invite>> {
     let channel = data.channel_id.channel(None).await?;
+    let server = if let Some(id) = channel.server_id {
+        Some(id.server(None).await?)
+    } else {
+        None
+    };
 
-    Permissions::fetch(&user, channel.server_id, channel.id.into())
+    Permissions::fetch_cached(&user, server.as_ref(), Some(&channel))
         .await?
-        .has(&[Permissions::INVITE_OTHERS])?;
+        .has(bits![INVITE_OTHERS])?;
 
     let invite = Invite::new(user.id, channel.id, channel.server_id);
 

src/routes/messages/create.rs

@@ -20,7 +20,7 @@ pub async fn create(
 ) -> Result<Json<Message>> {
     Permissions::fetch(&user, None, channel_id.into())
         .await?
-        .has(&[Permissions::VIEW_CHANNEL, Permissions::SEND_MESSAGES])?;
+        .has(bits![VIEW_CHANNEL, SEND_MESSAGES])?;
 
     let mut msg = Message::new(channel_id, user.id);
 

src/routes/messages/delete.rs

@@ -11,9 +11,9 @@ pub async fn delete(
     let p = Permissions::fetch(&user, None, channel_id.into()).await?;
 
     if msg.author_id != user.id {
-        p.has(&[Permissions::MANAGE_MESSAGES])?;
+        p.has(bits![MANAGE_MESSAGES])?;
     } else {
-        p.has(&[Permissions::MANAGE_MESSAGES, Permissions::VIEW_CHANNEL])?;
+        p.has(bits![MANAGE_MESSAGES, VIEW_CHANNEL])?;
     }
 
     let attachment_ids: Vec<i64> = msg

src/routes/messages/edit.rs

@@ -25,7 +25,7 @@ pub async fn edit(
 
     Permissions::fetch(&user, None, channel_id.into())
         .await?
-        .has(&[Permissions::VIEW_CHANNEL])?;
+        .has(bits![VIEW_CHANNEL])?;
 
     msg.content = data.content.into();
     msg.edited_at = Some(Utc::now().naive_utc());

src/routes/messages/fetch.rs

@@ -14,7 +14,7 @@ pub async fn fetch_one(
 
     Permissions::fetch(&user, None, channel_id.into())
         .await?
-        .has(&[Permissions::VIEW_CHANNEL, Permissions::READ_MESSAGE_HISTORY])?;
+        .has(bits![VIEW_CHANNEL, READ_MESSAGE_HISTORY])?;
 
     Ok(Json(msg))
 }

src/routes/servers/channels/create.rs

@@ -20,7 +20,7 @@ pub async fn create(
 ) -> Result<Json<Channel>> {
     Permissions::fetch(&user, server_id.into(), None)
         .await?
-        .has(&[Permissions::MANAGE_CHANNELS])?;
+        .has(bits![MANAGE_CHANNELS])?;
 
     let count = Channel::count(&format!("server_id = {}", server_id)).await?;
 

src/routes/servers/channels/delete.rs

@@ -11,7 +11,7 @@ pub async fn delete(
 
     Permissions::fetch(&user, server_id.into(), id.into())
         .await?
-        .has(&[Permissions::MANAGE_CHANNELS])?;
+        .has(bits![MANAGE_CHANNELS])?;
 
     channel.remove().await?;
 

src/routes/servers/channels/edit.rs

@@ -18,11 +18,12 @@ pub async fn edit(
     Path((server_id, id)): Path<(i64, i64)>,
     ValidatedJson(data): ValidatedJson<EditServerChannelOptions>,
 ) -> Result<Json<Channel>> {
-    Permissions::fetch(&user, server_id.into(), id.into())
-        .await?
-        .has(&[Permissions::MANAGE_CHANNELS])?;
-
     let mut channel = id.channel(None).await?;
+    let server = server_id.server(None).await?;
+
+    Permissions::fetch_cached(&user, Some(&server), Some(&channel))
+        .await?
+        .has(bits![MANAGE_CHANNELS])?;
 
     channel.merge(data);
 

src/routes/servers/edit.rs

@@ -22,7 +22,7 @@ pub async fn edit(
 
     Permissions::fetch_cached(&user, Some(&server), None)
         .await?
-        .has(&[Permissions::MANAGE_SERVER])?;
+        .has(bits![MANAGE_SERVER])?;
 
     server.merge(data);
 

src/routes/servers/invites/delete.rs

@@ -8,7 +8,7 @@ pub async fn delete(
 ) -> Result<()> {
     Permissions::fetch(&user, server_id.into(), None)
         .await?
-        .has(&[Permissions::MANAGE_INVITES])?;
+        .has(bits![MANAGE_INVITES])?;
 
     id.invite(server_id.into()).await?.remove().await?;
 

src/routes/servers/members/edit.rs

@@ -21,7 +21,7 @@ pub async fn edit(
     let p = Permissions::fetch(&user, server_id.into(), None).await?;
 
     if let Some(nickname) = &data.nickname {
-        p.has(&[Permissions::CHANGE_NICKNAME, Permissions::MANAGE_NICKNAMES])?;
+        p.has(bits![CHANGE_NICKNAME, MANAGE_NICKNAMES])?;
 
         member.nickname = if nickname.is_empty() {
             None
@@ -31,7 +31,7 @@ pub async fn edit(
     }
 
     if let Some(ids) = &data.roles {
-        p.has(&[Permissions::MANAGE_ROLES])?;
+        p.has(bits![MANAGE_ROLES])?;
 
         let mut roles = Role::select()
             .filter("server_id = $1")

src/routes/servers/members/kick.rs

@@ -10,7 +10,7 @@ pub async fn kick(
     if user.id != id {
         Permissions::fetch(&user, server_id.into(), None)
             .await?
-            .has(&[Permissions::KICK_MEMBERS])?;
+            .has(bits![KICK_MEMBERS])?;
     }
 
     id.member(server_id).await?.remove().await?;

src/routes/servers/roles/create.rs

@@ -24,7 +24,7 @@ pub async fn create(
 ) -> Result<Json<Role>> {
     Permissions::fetch(&user, server_id.into(), None)
         .await?
-        .has(&[Permissions::MANAGE_ROLES])?;
+        .has(bits![MANAGE_ROLES])?;
 
     let count = Role::count(&format!("server_id = {}", server_id)).await?;
 

src/routes/servers/roles/delete.rs

@@ -9,7 +9,7 @@ pub async fn delete(
 ) -> Result<()> {
     Permissions::fetch(&user, server_id.into(), None)
         .await?
-        .has(&[Permissions::MANAGE_ROLES])?;
+        .has(bits![MANAGE_ROLES])?;
 
     id.role(server_id).await?.remove().await?;
 

src/routes/servers/roles/edit.rs

@@ -23,7 +23,7 @@ pub async fn edit(
 ) -> Result<Json<Role>> {
     Permissions::fetch(&user, server_id.into(), None)
         .await?
-        .has(&[Permissions::MANAGE_ROLES])?;
+        .has(bits![MANAGE_ROLES])?;
 
     let mut role = id.role(server_id).await?;
 

src/structures/server.rs

@@ -1,7 +1,5 @@
 use super::*;
-use crate::database::pool;
-use crate::utils::permissions::*;
-use crate::utils::snowflake;
+use crate::utils::{permissions::*, snowflake};
 use ormlite::model::*;
 use serde::{Deserialize, Serialize};
 
@@ -42,32 +40,29 @@ impl Server {
             .unwrap()
     }
 
-    pub async fn fetch_member(&self, user_id: i64) -> Option<Member> {
+    pub async fn fetch_member(&self, user_id: i64) -> Result<Member, ormlite::Error> {
         Member::select()
             .filter("id = $1 AND server_id = $2")
             .bind(user_id)
             .bind(self.id)
-            .fetch_optional(pool())
+            .fetch_one(pool())
             .await
-            .unwrap()
     }
 
-    pub async fn fetch_roles(&self) -> Vec<Role> {
+    pub async fn fetch_roles(&self) -> Result<Vec<Role>, ormlite::Error> {
         Role::select()
             .filter("server_id = $1")
             .bind(self.id)
             .fetch_all(pool())
             .await
-            .unwrap()
     }
 
-    pub async fn fetch_channels(&self) -> Vec<Channel> {
+    pub async fn fetch_channels(&self) -> Result<Vec<Channel>, ormlite::Error> {
         Channel::select()
             .filter("server_id = $1")
             .bind(self.id)
             .fetch_all(pool())
             .await
-            .unwrap()
     }
 
     #[cfg(test)]

src/structures/user.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::database::pool;
 use crate::utils::{snowflake, Badges};
 use ormlite::model::*;
 use serde::{Deserialize, Serialize};

src/utils/badges.rs

@@ -13,7 +13,7 @@ use std::fmt;
 
 bitflags! {
     #[derive(Default)]
-    pub struct Badges: u64 {
+    pub struct Badges: i64 {
        const STAFF = 1 << 1;
        const DEVELOPER = 1 << 2;
        const SUPPORTER = 1 << 3;
@@ -35,8 +35,7 @@ impl Encode<'_, Postgres> for Badges {
 
 impl<'r> Decode<'r, Postgres> for Badges {
     fn decode(value: PgValueRef<'r>) -> Result<Self, BoxDynError> {
-        let bits: i64 = Decode::<Postgres>::decode(value)?;
-        Ok(Badges::from_bits(bits as u64).unwrap())
+        Ok(Badges::from_bits(Decode::<Postgres>::decode(value)?).unwrap())
     }
 }
 
@@ -62,24 +61,24 @@ impl<'de> Visitor<'de> for BadgesVisitor {
     where
         E: Error,
     {
-        self.visit_u64(v.parse().map_err(E::custom)?)
+        self.visit_i64(v.parse().map_err(E::custom)?)
     }
 
     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
     where
         E: Error,
     {
-        self.visit_u64(v.parse().map_err(E::custom)?)
+        self.visit_i64(v.parse().map_err(E::custom)?)
     }
 
-    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
     where
         E: Error,
     {
-        self.visit_u64(v as u64)
+        self.visit_i64(v as i64)
     }
 
-    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
     where
         E: Error,
     {

src/utils/email.rs

@@ -74,7 +74,7 @@ pub async fn send(user: &User) -> bool {
     }
 }
 
-pub async fn verify(user_id: u64, code: &str) -> bool {
+pub async fn verify(user_id: i64, code: &str) -> bool {
     match REDIS.get::<String, _>(user_id.to_string()).await {
         Ok(token) if code == token => {
             REDIS.del::<u32, _>(user_id.to_string()).await.ok();

src/utils/error.rs

@@ -23,8 +23,8 @@ quick_error! {
         InvalidToken { display("Unauthorized. Provide a valid token and try again") }
         EmailAlreadyInUse { display("This email already in use") }
 
-        MissingPermissions(missing: Vec<Permissions>) {
-            display("You lack permissions to perform that action, missing: {:?}", missing)
+        MissingPermissions(missing: Permissions) {
+            display("You lack permissions to perform that action, missing: {}", missing.bits())
         }
 
         EmptyMessage { display("Cannot send an empty message") }