chore: commit the things that are to be commited

src/routes/bots/create.rs

@@ -2,7 +2,7 @@ use crate::util::{regex::RE_USERNAME, variables::MAX_BOT_COUNT};
 
 use nanoid::nanoid;
 use revolt_quark::{
-    models::{Bot, User},
+    models::{Bot, User, user::BotInformation},
     Db, Error, Result,
 };
 
@@ -31,13 +31,28 @@ pub async fn create_bot(db: &Db, user: User, info: Json<Data>) -> Result<Json<Bo
         return Err(Error::ReachedMaximumBots);
     }
 
+    if db.is_username_taken(&info.name).await? {
+        return Err(Error::UsernameTaken);
+    }
+
+    let id = Ulid::new().to_string();
+    let bot_user = User {
+        id: id.clone(),
+        username: info.name,
+        bot: Some(BotInformation {
+            owner: user.id.clone()
+        }),
+        ..Default::default()
+    };
+
     let bot = Bot {
-        id: Ulid::new().to_string(),
+        id,
         owner: user.id,
         token: nanoid!(64),
         ..Default::default()
     };
 
+    db.insert_user(&bot_user).await?;
     db.insert_bot(&bot).await?;
     Ok(Json(bot))
 }

src/routes/bots/edit.rs

@@ -49,9 +49,9 @@ pub async fn edit_bot(db: &Db, user: User, target: Ref, data: Json<Data>) -> Res
     }
 
     if data.public.is_none()
-        || data.analytics.is_none()
+        && data.analytics.is_none()
-        || data.interactions_url.is_none()
+        && data.interactions_url.is_none()
-        || data.remove.is_none()
+        && data.remove.is_none()
     {
         return Ok(Json(bot));
     }

src/routes/bots/invite.rs

@@ -1,5 +1,5 @@
 use revolt_quark::{
-    models::{Channel, User, Member, server_member::MemberCompositeKey},
+    models::{server_member::MemberCompositeKey, Channel, Member, User},
     perms, ChannelPermission, Db, EmptyResponse, Error, Ref, Result, ServerPermission,
 };
 
@@ -46,14 +46,12 @@ pub async fn invite_bot(
             let member = Member {
                 id: MemberCompositeKey {
                     server: server.id,
-                    user: bot.id
+                    user: bot.id,
                 },
                 ..Default::default()
             };
 
-            db.insert_member(&member)
+            db.insert_member(&member).await.map(|_| EmptyResponse)
-                .await
-                .map(|_| EmptyResponse)
         }
         Destination::Group { group } => {
             let channel = db.fetch_channel(&group).await?;

src/routes/invites/invite_fetch.rs

@@ -77,25 +77,25 @@ pub async fn req(db: &Db, target: Ref) -> Result<Json<InviteResponse>> {
                 _ => unreachable!(),
             }
         }
-        Invite::Group { channel, creator, .. } => {
+        Invite::Group {
+            channel, creator, ..
+        } => {
             let channel = db.fetch_channel(&channel).await?;
             let user = db.fetch_user(&creator).await?;
 
             match channel {
-                | Channel::Group {
+                Channel::Group {
                     id,
                     name,
                     description,
                     ..
-                } => {
+                } => InviteResponse::Group {
-                    InviteResponse::Group {
+                    channel_id: id,
-                        channel_id: id,
+                    channel_name: name,
-                        channel_name: name,
+                    channel_description: description,
-                        channel_description: description,
+                    user_name: user.username,
-                        user_name: user.username,
+                    user_avatar: user.avatar,
-                        user_avatar: user.avatar,
+                },
-                    }
-                }
                 _ => unreachable!(),
             }
         }

src/routes/invites/invite_join.rs

@@ -1,5 +1,5 @@
 use revolt_quark::{
-    models::{Invite, User, server_member::MemberCompositeKey, Member},
+    models::{server_member::MemberCompositeKey, Invite, Member, User},
     Db, Error, Ref, Result,
 };
 
@@ -33,7 +33,7 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<Value> {
             let member = Member {
                 id: MemberCompositeKey {
                     server: server.id.clone(),
-                    user: user.id.clone()
+                    user: user.id.clone(),
                 },
                 ..Default::default()
             };

src/routes/servers/member_edit.rs

@@ -54,6 +54,7 @@ pub async fn req(
     };
 
     // ! FIXME: calculate permission against member
+    // ! FIXME: also check roles exist lol
 
     // 1. Remove fields from object
     if let Some(fields) = &remove {

src/routes/servers/permissions_set.rs

@@ -32,6 +32,12 @@ pub async fn req(
         return Err(Error::NotFound);
     }
 
+    // ! FIXME: calculate permission against role
+
+    if !server.roles.contains_key(&role_id) {
+        return Err(Error::NotFound);
+    }
+
     db.update_role_permission(
         &server.id,
         &role_id,

src/routes/servers/roles_delete.rs

@@ -12,6 +12,8 @@ pub async fn req(db: &Db, user: User, target: Ref, role_id: String) -> Result<Em
         return Err(Error::NotFound);
     }
 
+    // ! FIXME: check perms against role
+
     db.delete_role(&server.id, &role_id)
         .await
         .map(|_| EmptyResponse)

src/routes/servers/server_create.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use revolt_quark::{
-    models::{Channel, Server, User, server_member::MemberCompositeKey, Member},
+    models::{server_member::MemberCompositeKey, Channel, Member, Server, User},
     Db, Error, Result, DEFAULT_PERMISSION_CHANNEL_SERVER, DEFAULT_SERVER_PERMISSION,
 };