feat(sync): implement settings and unreads fetch

src/routes/bots/invite.rs

@@ -1,4 +1,7 @@
-use revolt_quark::{models::{User, Channel}, EmptyResponse, Error, Ref, Result, Db, perms, ServerPermission, ChannelPermission};
+use revolt_quark::{
+    models::{Channel, User},
+    perms, ChannelPermission, Db, EmptyResponse, Error, Ref, Result, ServerPermission,
+};
 
 use rocket::serde::json::Json;
 use serde::Deserialize;
@@ -11,33 +14,56 @@ pub enum Destination {
 }
 
 #[post("/<target>/invite", data = "<dest>")]
-pub async fn invite_bot(db: &Db, user: User, target: Ref, dest: Json<Destination>) -> Result<EmptyResponse> {
+pub async fn invite_bot(
+    db: &Db,
+    user: User,
+    target: Ref,
+    dest: Json<Destination>,
+) -> Result<EmptyResponse> {
     if user.bot.is_some() {
         return Err(Error::IsBot);
     }
 
     let bot = target.as_bot(db).await?;
     if !bot.public && bot.owner != user.id {
-        return Err(Error::BotIsPrivate)
+        return Err(Error::BotIsPrivate);
     }
 
     match dest.into_inner() {
         Destination::Server { 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 })
+            if !perms(&user)
+                .server(&server)
+                .calc_server(db)
+                .await
+                .get_manage_server()
+            {
+                return Err(Error::MissingPermission {
+                    permission: ServerPermission::ManageServer as i32,
+                });
             }
 
-            db.insert_member(&server.id, &bot.id).await.map(|_| EmptyResponse)
-        },
-        Destination::Group{ group } => {
+            db.insert_member(&server.id, &bot.id)
+                .await
+                .map(|_| EmptyResponse)
+        }
+        Destination::Group { group } => {
             let channel = db.fetch_channel(&group).await?;
-            if !perms(&user).channel(&channel).calc_channel(db).await.get_invite_others() {
-                return Err(Error::MissingPermission { permission: ChannelPermission::InviteOthers as i32 })
+            if !perms(&user)
+                .channel(&channel)
+                .calc_channel(db)
+                .await
+                .get_invite_others()
+            {
+                return Err(Error::MissingPermission {
+                    permission: ChannelPermission::InviteOthers as i32,
+                });
             }
 
             if let Channel::Group { id, .. } = channel {
-                db.add_user_to_group(&id, &bot.id).await.map(|_| EmptyResponse)
+                db.add_user_to_group(&id, &bot.id)
+                    .await
+                    .map(|_| EmptyResponse)
             } else {
                 Err(Error::InvalidOperation)
             }

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

src/routes/sync/get_settings.rs

@@ -1,8 +1,7 @@
-use revolt_quark::{Error, Result};
+use revolt_quark::{Result, models::{UserSettings, User}, Db};
 
 use mongodb::bson::doc;
-use mongodb::options::FindOneOptions;
-use rocket::serde::json::{Json, Value};
+use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
 
 #[derive(Serialize, Deserialize)]
@@ -11,6 +10,6 @@ pub struct Options {
 }
 
 #[post("/settings/fetch", data = "<options>")]
-pub async fn req(/*user: UserRef,*/ options: Json<Options>) -> Result<Value> {
-    todo!()
+pub async fn req(db: &Db, user: User, options: Json<Options>) -> Result<Json<UserSettings>> {
+    db.fetch_user_settings(&user.id, &options.into_inner().keys).await.map(Json)
 }

src/routes/sync/get_unreads.rs

@@ -1,9 +1,9 @@
-use revolt_quark::{Error, Result};
+use revolt_quark::{Result, models::{ChannelUnread, User}, Db};
 
 use mongodb::bson::doc;
-use rocket::serde::json::Value;
+use rocket::serde::json::Json;
 
 #[get("/unreads")]
-pub async fn req(/*user: UserRef*/) -> Result<Value> {
-    todo!()
+pub async fn req(db: &Db, user: User) -> Result<Json<Vec<ChannelUnread>>> {
+    db.fetch_unreads(&user.id).await.map(Json)
 }

src/routes/sync/set_settings.rs

@@ -1,11 +1,9 @@
-use revolt_quark::{EmptyResponse, Result};
+use revolt_quark::models::User;
+use revolt_quark::{EmptyResponse, Result, Db};
 
 use chrono::prelude::*;
-use mongodb::bson::{doc, to_bson};
-use mongodb::options::UpdateOptions;
 use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
-use serde_json::json;
 use std::collections::HashMap;
 
 type Data = HashMap<String, String>;
@@ -16,9 +14,26 @@ pub struct Options {
 }
 
 #[post("/settings/set?<options..>", data = "<data>")]
-pub async fn req(
-    /*user: UserRef,*/ data: Json<Data>,
-    options: Options,
-) -> Result<EmptyResponse> {
-    todo!()
+pub async fn req(db: &Db, user: User, data: Json<Data>, options: Options) -> Result<EmptyResponse> {
+    let data = data.into_inner();
+    let current_time = Utc::now().timestamp_millis();
+    let timestamp = if let Some(timestamp) = options.timestamp {
+        if timestamp > current_time {
+            current_time
+        } else {
+            timestamp
+        }
+    } else {
+        current_time
+    };
+
+    let mut settings = HashMap::new();
+    for (key, data) in data {
+        settings.insert(key, (
+            timestamp,
+            data
+        ));
+    }
+
+    db.set_user_settings(&user.id, &settings).await.map(|_| EmptyResponse)
 }