feat(sync): implement settings and unreads fetch

src/routes/invites/invite_delete.rs

@@ -1,6 +1,33 @@
-use revolt_quark::{EmptyResponse, Result};
+use revolt_quark::{
+    models::{Invite, User},
+    perms, Db, EmptyResponse, Error, Ref, Result, ServerPermission,
+};
 
 #[delete("/<target>")]
-pub async fn req(/*user: UserRef, target: Ref*/ target: String) -> Result<EmptyResponse> {
-    todo!()
+pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
+    let invite = target.as_invite(db).await?;
+
+    if user.id == invite.creator() {
+        db.delete_invite(invite.code()).await
+    } else {
+        match invite {
+            Invite::Server { code, server, .. } => {
+                let server = db.fetch_server(&server).await?;
+                if !perms(&user)
+                    .server(&server)
+                    .calc_server(db)
+                    .await
+                    .get_manage_server()
+                {
+                    return Err(Error::MissingPermission {
+                        permission: ServerPermission::ManageServer as i32,
+                    });
+                }
+
+                db.delete_invite(&code).await
+            }
+            _ => unreachable!(),
+        }
+    }
+    .map(|_| EmptyResponse)
 }

src/routes/invites/invite_fetch.rs

@@ -1,7 +1,7 @@
-use revolt_quark::models::File;
-use revolt_quark::Result;
+use revolt_quark::models::{Channel, File, Invite};
+use revolt_quark::{Db, Ref, Result};
 
-use rocket::serde::json::Value;
+use rocket::serde::json::Json;
 use serde::Serialize;
 
 #[derive(Serialize, Debug, Clone)]
@@ -26,6 +26,47 @@ pub enum InviteResponse {
 }
 
 #[get("/<target>")]
-pub async fn req(/*target: Ref*/ target: String) -> Result<Value> {
-    todo!()
+pub async fn req(db: &Db, target: Ref) -> Result<Json<InviteResponse>> {
+    Ok(Json(match target.as_invite(db).await? {
+        Invite::Server {
+            channel, creator, ..
+        } => {
+            let channel = db.fetch_channel(&channel).await?;
+            let user = db.fetch_user(&creator).await?;
+
+            match channel {
+                Channel::TextChannel {
+                    id,
+                    server,
+                    name,
+                    description,
+                    ..
+                }
+                | Channel::VoiceChannel {
+                    id,
+                    server,
+                    name,
+                    description,
+                    ..
+                } => {
+                    let server = db.fetch_server(&server).await?;
+
+                    InviteResponse::Server {
+                        member_count: db.fetch_member_count(&server.id).await? as i64,
+                        server_id: server.id,
+                        server_name: server.name,
+                        server_icon: server.icon,
+                        server_banner: server.banner,
+                        channel_id: id,
+                        channel_name: name,
+                        channel_description: description,
+                        user_name: user.username,
+                        user_avatar: user.avatar,
+                    }
+                }
+                _ => unreachable!(),
+            }
+        }
+        _ => unimplemented!(),
+    }))
 }