feat: allow editing owned bots using user edit route

clippy.toml

@@ -2,6 +2,11 @@ disallowed-methods = [
     # Shouldn't need to access these directly
     "revolt_database::models::bots::model::Bot::remove_field",
 
-    # Prefer to use Object::delete()
+    # Prefer to use Object::update()
     "revolt_database::models::bots::ops::AbstractBots::update_bot",
+    "revolt_database::models::safety_strikes::ops::AbstractAccountStrikes::update_account_strike",
+
+    # Prefer to use Object::delete()
+    "revolt_database::models::bots::ops::AbstractBots::delete_bot",
+    "revolt_database::models::safety_strikes::ops::AbstractAccountStrikes::delete_account_strike",
 ]

crates/core/database/src/drivers/reference.rs

@@ -2,12 +2,13 @@ use std::{collections::HashMap, sync::Arc};
 
 use futures::lock::Mutex;
 
-use crate::{Bot, File, Member, MemberCompositeKey, Server, User, UserSettings};
+use crate::{AccountStrike, Bot, File, Member, MemberCompositeKey, Server, User, UserSettings};
 
 database_derived!(
     /// Reference implementation
     #[derive(Default)]
     pub struct ReferenceDb {
+        pub account_strikes: Arc<Mutex<HashMap<String, AccountStrike>>>,
         pub bots: Arc<Mutex<HashMap<String, Bot>>>,
         pub user_settings: Arc<Mutex<HashMap<String, UserSettings>>>,
         pub users: Arc<Mutex<HashMap<String, User>>>,

crates/core/database/src/models/admin_migrations/ops/mongodb/init.rs

@@ -64,6 +64,10 @@ pub async fn create_database(db: &MongoDb) {
         .await
         .expect("Failed to create safety_snapshots collection.");
 
+    db.create_collection("safety_strikes", None)
+        .await
+        .expect("Failed to create safety_strikes collection.");
+
     db.create_collection("bots", None)
         .await
         .expect("Failed to create bots collection.");

crates/core/database/src/models/admin_migrations/ops/mongodb/scripts.rs

@@ -16,7 +16,7 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 21;
+pub const LATEST_REVISION: i32 = 22;
 
 pub async fn migrate_database(db: &MongoDb) {
     let migrations = db.col::<Document>("migrations");
@@ -696,26 +696,15 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     if revision <= 19 {
         info!("Running migration [revision 19 / 27-02-2023]: Create report / snapshot collections, migrate to new model if applicable.");
 
-        // TODO: make these fail once production is migrated
-        if db
-            .db()
+        db.db()
             .create_collection("safety_reports", None)
             .await
-            .is_err()
-        {
-            info!("Failed to create safety_reports collection but this is expected in production.");
-        }
+            .unwrap();
 
-        if db
-            .db()
+        db.db()
             .create_collection("safety_snapshots", None)
             .await
-            .is_err()
-        {
-            info!(
-                "Failed to create safety_snapshots collection but this is expected in production."
-            );
-        }
+            .unwrap();
 
         db.col::<Document>("safety_reports")
             .update_many(
@@ -753,6 +742,15 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .expect("Failed to create safety snapshot index.");
     }
 
+    if revision <= 21 {
+        info!("Running migration [revision 21 / 31-05-2023]: Add collection `safety_strikes`.");
+
+        db.db()
+            .create_collection("safety_strikes", None)
+            .await
+            .unwrap();
+    }
+
     // Need to migrate fields on attachments, change `user_id`, `object_id`, etc to `parent`.
 
     // Reminder to update LATEST_REVISION when adding new migrations.

crates/core/database/src/models/bots/model.rs

@@ -91,7 +91,7 @@ impl Bot {
 
 #[cfg(test)]
 mod tests {
-    use crate::{Bot, FieldsBot, PartialBot};
+    use crate::{Bot, FieldsBot, PartialBot, User};
 
     #[async_std::test]
     async fn crud() {
@@ -100,6 +100,14 @@ mod tests {
             let user_id = "user";
             let token = "my_token";
 
+            let user = User {
+                id: bot_id.to_string(),
+                username: "Bot Name".to_string(),
+                ..Default::default()
+            };
+
+            db.insert_user(&user).await.unwrap();
+
             let bot = Bot {
                 id: bot_id.to_string(),
                 owner: user_id.to_string(),
@@ -139,7 +147,8 @@ mod tests {
 
             bot.delete(&db).await.unwrap();
             assert!(db.fetch_bot(bot_id).await.is_err());
-            assert_eq!(0, db.get_number_of_bots_by_user(user_id).await.unwrap())
+            assert_eq!(0, db.get_number_of_bots_by_user(user_id).await.unwrap());
+            assert_eq!(db.fetch_user(bot_id).await.unwrap().flags, Some(2))
         });
     }
 }

crates/core/database/src/models/mod.rs

@@ -1,6 +1,7 @@
 mod admin_migrations;
 mod bots;
 mod files;
+mod safety_strikes;
 mod server_members;
 mod servers;
 mod user_settings;
@@ -9,6 +10,7 @@ mod users;
 pub use admin_migrations::*;
 pub use bots::*;
 pub use files::*;
+pub use safety_strikes::*;
 pub use server_members::*;
 pub use servers::*;
 pub use user_settings::*;
@@ -22,6 +24,7 @@ pub trait AbstractDatabase:
     + admin_migrations::AbstractMigrations
     + bots::AbstractBots
     + files::AbstractAttachments
+    + safety_strikes::AbstractAccountStrikes
     + server_members::AbstractServerMembers
     + servers::AbstractServers
     + user_settings::AbstractUserSettings

crates/core/database/src/models/safety_strikes/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;

crates/core/database/src/models/safety_strikes/model.rs

@@ -0,0 +1,105 @@
+use revolt_result::Result;
+
+use crate::Database;
+
+auto_derived_partial!(
+    /// Account Strike
+    pub struct AccountStrike {
+        /// Strike Id
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// User Id of reported user
+        pub user_id: String,
+
+        /// Attached reason
+        pub reason: String,
+    },
+    "PartialAccountStrike"
+);
+
+#[allow(clippy::disallowed_methods)]
+impl AccountStrike {
+    /// Update this strike
+    pub async fn update(&mut self, db: &Database, partial: PartialAccountStrike) -> Result<()> {
+        db.update_account_strike(&self.id, &partial).await?;
+        self.apply_options(partial);
+        Ok(())
+    }
+
+    /// Delete this strike
+    pub async fn delete(&self, db: &Database) -> Result<()> {
+        db.delete_account_strike(&self.id).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+
+    use crate::{AccountStrike, PartialAccountStrike};
+
+    #[async_std::test]
+    async fn crud() {
+        database_test!(|db| async move {
+            let user_id = "user";
+            let strike_a = "a";
+            let strike_b = "b";
+
+            let strike = AccountStrike {
+                id: strike_a.to_string(),
+                user_id: user_id.to_string(),
+                reason: "reason 1".to_string(),
+            };
+
+            db.insert_account_strike(&strike).await.unwrap();
+
+            let mut updated_strike = strike.clone();
+            updated_strike
+                .update(
+                    &db,
+                    PartialAccountStrike {
+                        reason: Some("new reason".to_string()),
+                        ..Default::default()
+                    },
+                )
+                .await
+                .unwrap();
+
+            db.insert_account_strike(&AccountStrike {
+                id: strike_b.to_string(),
+                user_id: user_id.to_string(),
+                reason: "reason 2".to_string(),
+            })
+            .await
+            .unwrap();
+
+            let strikes = db.fetch_account_strikes_by_user(user_id).await.unwrap();
+
+            let ids = strikes
+                .iter()
+                .cloned()
+                .map(|strike| strike.id)
+                .collect::<HashSet<String>>();
+
+            assert!(ids.contains(strike_a));
+            assert!(ids.contains(strike_b));
+
+            let fetched_strike = strikes
+                .into_iter()
+                .find(|strike| strike.id == strike_a)
+                .unwrap();
+
+            assert_eq!(fetched_strike, updated_strike);
+            assert_ne!(fetched_strike, strike);
+
+            strike.delete(&db).await.unwrap();
+            assert_eq!(
+                1,
+                db.fetch_account_strikes_by_user(user_id)
+                    .await
+                    .unwrap()
+                    .len()
+            )
+        });
+    }
+}

crates/core/database/src/models/safety_strikes/ops.rs

@@ -0,0 +1,24 @@
+use revolt_result::Result;
+
+use crate::{AccountStrike, PartialAccountStrike};
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractAccountStrikes: Sync + Send {
+    /// Insert new strike into the database
+    async fn insert_account_strike(&self, strike: &AccountStrike) -> Result<()>;
+
+    /// Fetch strike by id
+    async fn fetch_account_strike(&self, id: &str) -> Result<AccountStrike>;
+
+    /// Fetch strikes by user id
+    async fn fetch_account_strikes_by_user(&self, user_id: &str) -> Result<Vec<AccountStrike>>;
+
+    /// Update strike with new information
+    async fn update_account_strike(&self, id: &str, partial: &PartialAccountStrike) -> Result<()>;
+
+    /// Delete a strike from the database
+    async fn delete_account_strike(&self, id: &str) -> Result<()>;
+}

crates/core/database/src/models/safety_strikes/ops/mongodb.rs

@@ -0,0 +1,55 @@
+use futures::StreamExt;
+use revolt_result::Result;
+
+use crate::MongoDb;
+use crate::{AccountStrike, PartialAccountStrike};
+
+use super::AbstractAccountStrikes;
+
+static COL: &str = "bots";
+
+#[async_trait]
+impl AbstractAccountStrikes for MongoDb {
+    /// Insert new strike into the database
+    async fn insert_account_strike(&self, strike: &AccountStrike) -> Result<()> {
+        query!(self, insert_one, COL, &strike).map(|_| ())
+    }
+
+    /// Fetch strike by id
+    async fn fetch_account_strike(&self, id: &str) -> Result<AccountStrike> {
+        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch strikes by user id
+    async fn fetch_account_strikes_by_user(&self, user_id: &str) -> Result<Vec<AccountStrike>> {
+        Ok(self
+            .col::<AccountStrike>(COL)
+            .find(
+                doc! {
+                    "user_id": user_id,
+                },
+                None,
+            )
+            .await
+            .map_err(|_| create_database_error!("find", COL))?
+            .filter_map(|s| async {
+                if cfg!(debug_assertions) {
+                    Some(s.unwrap())
+                } else {
+                    s.ok()
+                }
+            })
+            .collect()
+            .await)
+    }
+
+    /// Update strike with new information
+    async fn update_account_strike(&self, id: &str, partial: &PartialAccountStrike) -> Result<()> {
+        query!(self, update_one_by_id, COL, id, partial, vec![], None).map(|_| ())
+    }
+
+    /// Delete a strike from the database
+    async fn delete_account_strike(&self, id: &str) -> Result<()> {
+        query!(self, delete_one_by_id, COL, id).map(|_| ())
+    }
+}

crates/core/database/src/models/safety_strikes/ops/reference.rs

@@ -0,0 +1,60 @@
+use revolt_result::Result;
+
+use crate::ReferenceDb;
+use crate::{AccountStrike, PartialAccountStrike};
+
+use super::AbstractAccountStrikes;
+
+#[async_trait]
+impl AbstractAccountStrikes for ReferenceDb {
+    /// Insert new strike into the database
+    async fn insert_account_strike(&self, strike: &AccountStrike) -> Result<()> {
+        let mut strikes = self.account_strikes.lock().await;
+        if strikes.contains_key(&strike.id) {
+            Err(create_database_error!("insert", "strike"))
+        } else {
+            strikes.insert(strike.id.to_string(), strike.clone());
+            Ok(())
+        }
+    }
+
+    /// Fetch strike by id
+    async fn fetch_account_strike(&self, id: &str) -> Result<AccountStrike> {
+        let strikes = self.account_strikes.lock().await;
+        strikes
+            .get(id)
+            .cloned()
+            .ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch strikes by user id
+    async fn fetch_account_strikes_by_user(&self, user_id: &str) -> Result<Vec<AccountStrike>> {
+        let strikes = self.account_strikes.lock().await;
+        Ok(strikes
+            .values()
+            .filter(|strike| strike.user_id == user_id)
+            .cloned()
+            .collect())
+    }
+
+    /// Update strike with new information
+    async fn update_account_strike(&self, id: &str, partial: &PartialAccountStrike) -> Result<()> {
+        let mut strikes = self.account_strikes.lock().await;
+        if let Some(strike) = strikes.get_mut(id) {
+            strike.apply_options(partial.clone());
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Delete a strike from the database
+    async fn delete_account_strike(&self, id: &str) -> Result<()> {
+        let mut strikes = self.account_strikes.lock().await;
+        if strikes.remove(id).is_some() {
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+}

crates/core/database/src/models/users/model.rs

@@ -76,7 +76,7 @@ auto_derived!(
     /// User's active status
     pub struct UserStatus {
         /// Custom status text
-        #[serde(skip_serializing_if = "String::is_empty")]
+        #[serde(skip_serializing_if = "String::is_empty", default)]
         pub text: String,
         /// Current presence option
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -86,7 +86,7 @@ auto_derived!(
     /// User's profile
     pub struct UserProfile {
         /// Text content on user's profile
-        #[serde(skip_serializing_if = "String::is_empty")]
+        #[serde(skip_serializing_if = "String::is_empty", default)]
         pub content: String,
         /// Background visible on user's profile
         #[serde(skip_serializing_if = "Option::is_none")]
@@ -111,6 +111,7 @@ auto_derived!(
 
 impl User {
     /// Check whether a username is already in use by another user
+    #[allow(dead_code)]
     async fn is_username_taken(db: &Database, username: &str) -> Result<bool> {
         match db.fetch_user_by_username(username).await {
             Ok(_) => Ok(true),

crates/core/database/src/util/permissions.rs

@@ -8,6 +8,7 @@ use crate::{Database, User};
 
 /// Permissions calculator
 pub struct PermissionCalculator<'a> {
+    #[allow(dead_code)]
     database: &'a Database,
 
     perspective: &'a User,

crates/core/models/src/v0/account_strikes.rs

@@ -0,0 +1,30 @@
+auto_derived!(
+    /// Account Strike
+    pub struct AccountStrike {
+        /// Strike Id
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// User Id of reported user
+        pub user_id: String,
+
+        /// Attached reason
+        pub reason: String,
+    }
+
+    /// # Strike Data
+    pub struct DataEditAccountStrike {
+        /// New attached reason
+        pub reason: String,
+    }
+);
+
+#[cfg(feature = "from_database")]
+impl From<revolt_database::AccountStrike> for AccountStrike {
+    fn from(value: revolt_database::AccountStrike) -> Self {
+        AccountStrike {
+            id: value.id,
+            user_id: value.user_id,
+            reason: value.reason,
+        }
+    }
+}

crates/core/models/src/v0/mod.rs

@@ -1,7 +1,9 @@
+mod account_strikes;
 mod bots;
 mod files;
 mod users;
 
+pub use account_strikes::*;
 pub use bots::*;
 pub use files::*;
 pub use users::*;

crates/delta/src/routes/channels/members_fetch.rs

@@ -11,10 +11,6 @@ use rocket::serde::json::Json;
 #[openapi(tag = "Groups")]
 #[get("/<target>/members")]
 pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Vec<User>>> {
-    if user.bot.is_some() {
-        return Err(Error::IsBot);
-    }
-
     let channel = target.as_channel(db).await?;
     perms(&user)
         .channel(&channel)

crates/delta/src/routes/safety/delete_strike.rs

@@ -0,0 +1,23 @@
+use revolt_database::Database;
+use revolt_quark::models::User;
+use revolt_quark::{Error, Result};
+use rocket::State;
+
+/// # Delete Strike
+///
+/// Delete a strike by its ID
+#[openapi(tag = "User Safety")]
+#[delete("/strikes/<strike_id>")]
+pub async fn delete_strike(db: &State<Database>, user: User, strike_id: String) -> Result<()> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    let strike = db
+        .fetch_account_strike(&strike_id)
+        .await
+        .map_err(Error::from_core)?;
+
+    strike.delete(db).await.map_err(Error::from_core)
+}

crates/delta/src/routes/safety/edit_strike.rs

@@ -0,0 +1,39 @@
+use revolt_database::{Database, PartialAccountStrike};
+use revolt_models::v0::DataEditAccountStrike;
+use revolt_quark::models::User;
+use revolt_quark::{Error, Result};
+use rocket::serde::json::Json;
+use rocket::State;
+
+/// # Edit Strike
+///
+/// Edit a strike by its ID
+#[openapi(tag = "User Safety")]
+#[post("/strikes/<strike_id>", data = "<data>")]
+pub async fn edit_strike(
+    db: &State<Database>,
+    user: User,
+    strike_id: String,
+    data: Json<DataEditAccountStrike>,
+) -> Result<()> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    let mut strike = db
+        .fetch_account_strike(&strike_id)
+        .await
+        .map_err(Error::from_core)?;
+
+    strike
+        .update(
+            db,
+            PartialAccountStrike {
+                reason: Some(data.0.reason),
+                ..Default::default()
+            },
+        )
+        .await
+        .map_err(Error::from_core)
+}

crates/delta/src/routes/safety/fetch_reports.rs

@@ -1,17 +1,61 @@
+use revolt_quark::models::report::{ReportStatus, ReportStatusString, ReportedContent};
 use revolt_quark::models::{Report, User};
 use revolt_quark::{Db, Error, Result};
 use rocket::serde::json::Json;
+use serde::Deserialize;
+
+/// # Query Parameters
+#[derive(Deserialize, JsonSchema, FromForm)]
+pub struct OptionsFetchReports {
+    /// Find reports against messages, servers, or users
+    content_id: Option<String>,
+
+    /// Find reports created by user
+    author_id: Option<String>,
+
+    /// Report status to include in search
+    status: Option<ReportStatusString>,
+}
 
 /// # Fetch Reports
 ///
 /// Fetch all available reports
 #[openapi(tag = "User Safety")]
-#[get("/reports")]
-pub async fn fetch_reports(db: &Db, user: User) -> Result<Json<Vec<Report>>> {
+#[get("/reports?<options..>")]
+pub async fn fetch_reports(
+    db: &Db,
+    user: User,
+    options: OptionsFetchReports,
+) -> Result<Json<Vec<Report>>> {
     // Must be privileged for this route
     if !user.privileged {
         return Err(Error::NotPrivileged);
     }
 
-    db.fetch_reports().await.map(Json)
+    let mut reports = db.fetch_reports().await?;
+
+    if let Some(content_id) = options.content_id {
+        reports.retain(|report| match &report.content {
+            ReportedContent::Message { id, .. }
+            | ReportedContent::Server { id, .. }
+            | ReportedContent::User { id, .. } => id == &content_id,
+        });
+    }
+
+    if let Some(author_id) = options.author_id {
+        reports.retain(|report| report.author_id == author_id);
+    }
+
+    if let Some(status) = options.status {
+        reports.retain(|report| {
+            matches!(
+                (&status, &report.status),
+                (ReportStatusString::Created, ReportStatus::Created { .. })
+                    | (ReportStatusString::Rejected, ReportStatus::Rejected { .. })
+                    | (ReportStatusString::Resolved, ReportStatus::Resolved { .. })
+            )
+        });
+    }
+
+    Ok(Json(reports))
 }

crates/delta/src/routes/safety/fetch_snapshot.rs

@@ -1,82 +0,0 @@
-use std::collections::HashSet;
-
-use revolt_quark::models::snapshot::{SnapshotContent, SnapshotWithContext};
-use revolt_quark::models::{Channel, User};
-use revolt_quark::{Db, Error, Result};
-use rocket::serde::json::Json;
-
-/// # Fetch Snapshot
-///
-/// Fetch a snapshot for a given report
-#[openapi(tag = "User Safety")]
-#[get("/snapshot/<report_id>")]
-pub async fn fetch_snapshot(
-    db: &Db,
-    user: User,
-    report_id: String,
-) -> Result<Json<SnapshotWithContext>> {
-    // Must be privileged for this route
-    if !user.privileged {
-        return Err(Error::NotPrivileged);
-    }
-
-    // Fetch snapshot
-    let snapshot = db.fetch_snapshot(&report_id).await?;
-
-    // Resolve and fetch IDs of associated content
-    let mut user_ids: HashSet<&str> = HashSet::new();
-    let mut channel_ids: HashSet<&str> = HashSet::new();
-
-    match &snapshot.content {
-        SnapshotContent::Message {
-            prior_context,
-            leading_context,
-            message,
-        } => {
-            for msg in prior_context {
-                user_ids.insert(&msg.author);
-            }
-
-            for msg in leading_context {
-                user_ids.insert(&msg.author);
-            }
-
-            user_ids.insert(&message.author);
-            channel_ids.insert(&message.channel);
-        }
-        SnapshotContent::User(user) => {
-            user_ids.insert(&user.id);
-        }
-        SnapshotContent::Server(server) => {
-            for channel in &server.channels {
-                channel_ids.insert(channel);
-            }
-        }
-    }
-
-    // Collect user and channel IDs
-    let user_ids: Vec<String> = user_ids.into_iter().map(|s| s.to_owned()).collect();
-    let channel_ids: Vec<String> = channel_ids.into_iter().map(|s| s.to_owned()).collect();
-
-    // Fetch users and channels
-    let users = db.fetch_users(&user_ids).await?;
-    let channels = db.fetch_channels(&channel_ids).await?;
-
-    // Pull out first server from channels if possible
-    let server = if let Some(server_id) = channels.iter().find_map(|channel| match channel {
-        Channel::TextChannel { server, .. } => Some(server),
-        _ => None,
-    }) {
-        Some(db.fetch_server(server_id).await?)
-    } else {
-        None
-    };
-
-    // Return snapshot with context
-    Ok(Json(SnapshotWithContext {
-        snapshot,
-        users,
-        channels,
-        server,
-    }))
-}

crates/delta/src/routes/safety/fetch_snapshots.rs

@@ -0,0 +1,87 @@
+use std::collections::HashSet;
+
+use revolt_quark::models::snapshot::{SnapshotContent, SnapshotWithContext};
+use revolt_quark::models::{Channel, User};
+use revolt_quark::{Db, Error, Result};
+use rocket::serde::json::Json;
+
+/// # Fetch Snapshots
+///
+/// Fetch a snapshots for a given report
+#[openapi(tag = "User Safety")]
+#[get("/snapshot/<report_id>")]
+pub async fn fetch_snapshots(
+    db: &Db,
+    user: User,
+    report_id: String,
+) -> Result<Json<Vec<SnapshotWithContext>>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    // Fetch snapshots
+    let snapshots = db.fetch_snapshots(&report_id).await?;
+    let mut result = vec![];
+
+    for snapshot in snapshots {
+        // Resolve and fetch IDs of associated content
+        let mut user_ids: HashSet<&str> = HashSet::new();
+        let mut channel_ids: HashSet<&str> = HashSet::new();
+
+        match &snapshot.content {
+            SnapshotContent::Message {
+                prior_context,
+                leading_context,
+                message,
+            } => {
+                for msg in prior_context {
+                    user_ids.insert(&msg.author);
+                }
+
+                for msg in leading_context {
+                    user_ids.insert(&msg.author);
+                }
+
+                user_ids.insert(&message.author);
+                channel_ids.insert(&message.channel);
+            }
+            SnapshotContent::User(user) => {
+                user_ids.insert(&user.id);
+            }
+            SnapshotContent::Server(server) => {
+                for channel in &server.channels {
+                    channel_ids.insert(channel);
+                }
+            }
+        }
+
+        // Collect user and channel IDs
+        let user_ids: Vec<String> = user_ids.into_iter().map(|s| s.to_owned()).collect();
+        let channel_ids: Vec<String> = channel_ids.into_iter().map(|s| s.to_owned()).collect();
+
+        // Fetch users and channels
+        let users = db.fetch_users(&user_ids).await?;
+        let channels = db.fetch_channels(&channel_ids).await?;
+
+        // Pull out first server from channels if possible
+        let server = if let Some(server_id) = channels.iter().find_map(|channel| match channel {
+            Channel::TextChannel { server, .. } => Some(server),
+            _ => None,
+        }) {
+            Some(db.fetch_server(server_id).await?)
+        } else {
+            None
+        };
+
+        // Return snapshot with context
+        result.push(SnapshotWithContext {
+            snapshot,
+            users,
+            channels,
+            server,
+        });
+    }
+
+    Ok(Json(result))
+}

crates/delta/src/routes/safety/fetch_strikes.rs

@@ -0,0 +1,28 @@
+use revolt_database::Database;
+use revolt_models::v0::AccountStrike;
+use revolt_quark::models::User;
+use revolt_quark::{Error, Result};
+use rocket::serde::json::Json;
+use rocket::State;
+
+/// # Fetch Strikes
+///
+/// Fetch strikes for a user by their ID
+#[openapi(tag = "User Safety")]
+#[get("/strikes/<user_id>")]
+pub async fn fetch_strikes(
+    db: &State<Database>,
+    user: User,
+    user_id: String,
+) -> Result<Json<Vec<AccountStrike>>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    db.fetch_account_strikes_by_user(&user_id)
+        .await
+        .map(|v| v.into_iter().map(|e| e.into()).collect())
+        .map(Json)
+        .map_err(Error::from_core)
+}

crates/delta/src/routes/safety/mod.rs

@@ -6,7 +6,11 @@ mod fetch_report;
 mod fetch_reports;
 mod report_content;
 
-mod fetch_snapshot;
+mod fetch_snapshots;
+
+mod delete_strike;
+mod edit_strike;
+mod fetch_strikes;
 
 pub fn routes() -> (Vec<Route>, OpenApi) {
     openapi_get_routes_spec![
@@ -16,6 +20,10 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         fetch_reports::fetch_reports,
         report_content::report_content,
         // Snapshots
-        fetch_snapshot::fetch_snapshot
+        fetch_snapshots::fetch_snapshots,
+        // Strikes
+        fetch_strikes::fetch_strikes,
+        edit_strike::edit_strike,
+        delete_strike::delete_strike
     ]
 }

crates/delta/src/routes/safety/report_content.rs

@@ -1,5 +1,4 @@
 use revolt_quark::events::client::EventV1;
-use revolt_quark::models::message::{MessageFilter, MessageQuery, MessageSort, MessageTimePeriod};
 use revolt_quark::models::report::{ReportStatus, ReportedContent};
 use revolt_quark::models::snapshot::{Snapshot, SnapshotContent};
 use revolt_quark::models::{Report, User};
@@ -38,7 +37,7 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
 
     // Find the content and create a snapshot of it
     // Also retrieve any references to Files
-    let (content, files): (SnapshotContent, Vec<String>) = match &data.content {
+    let (snapshots, files): (Vec<SnapshotContent>, Vec<String>) = match &data.content {
         ReportedContent::Message { id, .. } => {
             let message = db.fetch_message(id).await?;
 
@@ -47,53 +46,8 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
                 return Err(Error::CannotReportYourself);
             }
 
-            // Collect message attachments
-            let files = message
-                .attachments
-                .as_ref()
-                .map(|attachments| attachments.iter().map(|x| x.id.to_string()).collect())
-                .unwrap_or_default();
-
-            // Collect prior context
-            let prior_context = db
-                .fetch_messages(MessageQuery {
-                    filter: MessageFilter {
-                        channel: Some(message.channel.to_string()),
-                        ..Default::default()
-                    },
-                    limit: Some(15),
-                    time_period: MessageTimePeriod::Absolute {
-                        before: Some(message.id.to_string()),
-                        after: None,
-                        sort: Some(MessageSort::Latest),
-                    },
-                })
-                .await?;
-
-            // Collect leading context
-            let leading_context = db
-                .fetch_messages(MessageQuery {
-                    filter: MessageFilter {
-                        channel: Some(message.channel.to_string()),
-                        ..Default::default()
-                    },
-                    limit: Some(15),
-                    time_period: MessageTimePeriod::Absolute {
-                        before: None,
-                        after: Some(message.id.to_string()),
-                        sort: Some(MessageSort::Oldest),
-                    },
-                })
-                .await?;
-
-            (
-                SnapshotContent::Message {
-                    message,
-                    prior_context,
-                    leading_context,
-                },
-                files,
-            )
+            let (snapshot, files) = SnapshotContent::generate_from_message(db, message).await?;
+            (vec![snapshot], files)
         }
         ReportedContent::Server { id, .. } => {
             let server = db.fetch_server(id).await?;
@@ -103,15 +57,10 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
                 return Err(Error::CannotReportYourself);
             }
 
-            // Collect server's icon and banner
-            let files = [&server.icon, &server.banner]
-                .iter()
-                .filter_map(|x| x.as_ref().map(|x| x.id.to_string()))
-                .collect();
-
-            (SnapshotContent::Server(server), files)
+            let (snapshot, files) = SnapshotContent::generate_from_server(server)?;
+            (vec![snapshot], files)
         }
-        ReportedContent::User { id, .. } => {
+        ReportedContent::User { id, message_id, .. } => {
             let reported_user = db.fetch_user(id).await?;
 
             // Users cannot report themselves
@@ -119,19 +68,25 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
                 return Err(Error::CannotReportYourself);
             }
 
-            // Collect user's avatar and profile background
-            let files = [
-                reported_user.avatar.as_ref(),
-                reported_user
-                    .profile
-                    .as_ref()
-                    .and_then(|profile| profile.background.as_ref()),
-            ]
-            .iter()
-            .filter_map(|x| x.as_ref().map(|x| x.id.to_string()))
-            .collect();
+            // Determine if there is a message provided as context
+            let message = if let Some(id) = message_id {
+                db.fetch_message(id).await.ok()
+            } else {
+                None
+            };
 
-            (SnapshotContent::User(reported_user), files)
+            let (snapshot, files) = SnapshotContent::generate_from_user(reported_user)?;
+
+            if let Some(message) = message {
+                let (message_snapshot, message_files) =
+                    SnapshotContent::generate_from_message(db, message).await?;
+                (
+                    vec![snapshot, message_snapshot],
+                    [files, message_files].concat(),
+                )
+            } else {
+                (vec![snapshot], files)
+            }
         }
     };
 
@@ -143,14 +98,17 @@ pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>)
     // Generate an id for the report
     let id = Ulid::new().to_string();
 
-    // Save a snapshot of the content
-    let snapshot = Snapshot {
-        id: Ulid::new().to_string(),
-        report_id: id.to_string(),
-        content,
-    };
+    // Insert all new generated snapshots
+    for content in snapshots {
+        // Save a snapshot of the content
+        let snapshot = Snapshot {
+            id: Ulid::new().to_string(),
+            report_id: id.to_string(),
+            content,
+        };
 
-    db.insert_snapshot(&snapshot).await?;
+        db.insert_snapshot(&snapshot).await?;
+    }
 
     // Save the report
     let report = Report {

crates/delta/src/routes/servers/member_experimental_query.rs

@@ -0,0 +1,82 @@
+use revolt_quark::{
+    models::{Member, User},
+    perms, Db, Error, Ref, Result,
+};
+
+use rocket::serde::json::Json;
+use serde::{Deserialize, Serialize};
+
+/// # Query Parameters
+#[derive(Deserialize, JsonSchema, FromForm)]
+pub struct OptionsQueryMembers {
+    /// String to search for
+    query: String,
+
+    /// Discourage use of this API
+    experimental_api: bool,
+}
+
+/// # Query members by name
+#[derive(Serialize, JsonSchema)]
+pub struct MemberQueryResponse {
+    /// List of members
+    members: Vec<Member>,
+    /// List of users
+    users: Vec<User>,
+}
+
+/// # Query members by name
+///
+/// Query members by a given name, this API is not stable and will be removed in the future.
+#[openapi(tag = "Server Members")]
+#[get("/<target>/members_experimental_query?<options..>")]
+pub async fn member_experimental_query(
+    db: &Db,
+    user: User,
+    target: Ref,
+    options: OptionsQueryMembers,
+) -> Result<Json<MemberQueryResponse>> {
+    if !options.experimental_api {
+        return Err(Error::InternalError);
+    }
+
+    let server = target.as_server(db).await?;
+    perms(&user).server(&server).calc(db).await?;
+
+    let mut members = db.fetch_all_members(&server.id).await?;
+
+    let mut user_ids = vec![];
+    for member in &members {
+        user_ids.push(member.id.user.clone());
+    }
+
+    let mut users = User::fetch_foreign_users(db, &user_ids).await?;
+
+    // Ensure the lists match up exactly
+    members.sort_by(|a, b| a.id.user.cmp(&b.id.user));
+    users.sort_by(|a, b| a.id.cmp(&b.id));
+
+    // Filter all matches
+    let mut zipped_vec: Vec<(Member, User)> = members
+        .into_iter()
+        .zip(users)
+        .filter(|(member, user)| {
+            if let Some(nickname) = &member.nickname {
+                nickname.contains(&options.query)
+            } else {
+                user.username.contains(&options.query)
+            }
+        })
+        .collect();
+
+    // Sort remaining matches by length
+    zipped_vec.sort_by(|(member_a, user_a), (member_b, user_b)| {
+        let left = member_a.nickname.as_ref().unwrap_or(&user_a.username);
+        let right = member_b.nickname.as_ref().unwrap_or(&user_b.username);
+        left.len().cmp(&right.len())
+    });
+
+    // Take the first five and return them
+    let (members, users) = zipped_vec.into_iter().take(10).unzip();
+    Ok(Json(MemberQueryResponse { members, users }))
+}

crates/delta/src/routes/servers/mod.rs

@@ -8,6 +8,7 @@ mod channel_create;
 mod emoji_list;
 mod invites_fetch;
 mod member_edit;
+mod member_experimental_query;
 mod member_fetch;
 mod member_fetch_all;
 mod member_remove;
@@ -34,6 +35,7 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         member_remove::req,
         member_fetch::req,
         member_edit::req,
+        member_experimental_query::member_experimental_query,
         ban_create::req,
         ban_remove::req,
         ban_list::req,

crates/delta/src/routes/servers/server_fetch.rs

@@ -1,17 +1,65 @@
 use revolt_quark::{
-    models::{Server, User},
+    models::{Channel, Server, User},
     perms, Db, Ref, Result,
 };
 use rocket::serde::json::Json;
+use serde::{Deserialize, Serialize};
+
+/// # Query Parameters
+#[derive(Deserialize, JsonSchema, FromForm)]
+pub struct OptionsFetchServer {
+    /// Whether to include channels
+    include_channels: Option<bool>,
+}
+
+/// # Fetch server route response
+#[derive(Serialize, JsonSchema)]
+#[serde(untagged)]
+pub enum FetchServerResponse {
+    JustServer(Server),
+    ServerWithChannels {
+        #[serde(flatten)]
+        server: Server,
+        channels: Vec<Channel>,
+    },
+}
 
 /// # Fetch Server
 ///
 /// Fetch a server by its id.
 #[openapi(tag = "Server Information")]
-#[get("/<target>")]
-pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Server>> {
+#[get("/<target>?<options..>")]
+pub async fn req(
+    db: &Db,
+    user: User,
+    target: Ref,
+    options: OptionsFetchServer,
+) -> Result<Json<FetchServerResponse>> {
     let server = target.as_server(db).await?;
-    perms(&user).server(&server).calc(db).await?;
+    let mut perms = perms(&user).server(&server);
+    perms.calc(db).await?;
 
-    Ok(Json(server))
+    if let Some(true) = options.include_channels {
+        let all_channels = db.fetch_channels(&server.channels).await?;
+        let mut visible_channels = vec![];
+
+        for channel in all_channels {
+            if perms
+                .clone()
+                .channel(&channel)
+                .calc(db)
+                .await?
+                .can_view_channel()
+            {
+                visible_channels.push(channel);
+            }
+        }
+
+        Ok(Json(FetchServerResponse::ServerWithChannels {
+            server,
+            channels: visible_channels,
+        }))
+    } else {
+        Ok(Json(FetchServerResponse::JustServer(server)))
+    }
 }

crates/delta/src/routes/users/edit_user.rs

@@ -66,14 +66,20 @@ pub async fn req(
 
     // If we want to edit a different user than self, ensure we have
     // permissions and subsequently replace the user in question
-    if target.id != "@me" {
-        if !user.privileged {
+    if target.id != "@me" && target.id != user.id {
+        let target_user = target.as_user(db).await?;
+        let is_bot_owner = target_user
+            .bot
+            .map(|bot| bot.owner == user.id)
+            .unwrap_or_default();
+
+        if !is_bot_owner && !user.privileged {
             return Err(Error::NotPrivileged);
         }
+    }
 
-        user = target.as_user(db).await?;
     // Otherwise, filter out invalid edit fields
-    } else if data.badges.is_some() || data.flags.is_some() {
+    if !user.privileged && (data.badges.is_some() || data.flags.is_some()) {
         return Err(Error::NotPrivileged);
     }
 

crates/quark/src/events/client.rs

@@ -183,6 +183,7 @@ pub enum EventV1 {
         id: String,
         data: PartialUser,
         clear: Vec<FieldsUser>,
+        event_id: Option<String>,
     },
 
     /// Relationship with another user changed

crates/quark/src/events/impl.rs

@@ -302,6 +302,7 @@ impl State {
                     ..Default::default()
                 },
                 clear: vec![],
+                event_id: Some(ulid::Ulid::new().to_string()),
             };
 
             for server in self.cache.servers.keys() {
@@ -499,6 +500,17 @@ impl State {
                 }
             }
 
+            EventV1::UserUpdate { event_id, .. } => {
+                if let Some(id) = event_id {
+                    if self.cache.seen_events.contains(id) {
+                        return false;
+                    }
+
+                    self.cache.seen_events.put(id.to_string(), ());
+                }
+
+                *event_id = None;
+            }
             EventV1::UserRelationship { id, user, .. } => {
                 self.cache.users.insert(id.clone(), user.clone());
 
@@ -508,6 +520,7 @@ impl State {
                     self.remove_subscription(id);
                 }
             }
+
             _ => {}
         }
 

crates/quark/src/events/state.rs

@@ -1,5 +1,7 @@
 use std::collections::{HashMap, HashSet};
 
+use lru::LruCache;
+
 use crate::models::{Channel, Member, Server, User};
 
 /// Enumeration representing some change in subscriptions
@@ -26,7 +28,7 @@ pub enum SubscriptionStateChange {
 /// ------------------------------------------------
 /// We can strip these objects to core information!!
 /// ------------------------------------------------
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct Cache {
     pub user_id: String,
 
@@ -34,6 +36,23 @@ pub struct Cache {
     pub channels: HashMap<String, Channel>,
     pub members: HashMap<String, Member>,
     pub servers: HashMap<String, Server>,
+
+    pub seen_events: LruCache<String, ()>,
+}
+
+impl Default for Cache {
+    fn default() -> Self {
+        Cache {
+            user_id: Default::default(),
+
+            users: Default::default(),
+            channels: Default::default(),
+            members: Default::default(),
+            servers: Default::default(),
+
+            seen_events: LruCache::new(20),
+        }
+    }
 }
 
 /// Client state

crates/quark/src/impl/dummy/safety/snapshot.rs

@@ -10,7 +10,7 @@ impl AbstractSnapshot for DummyDb {
         Ok(())
     }
 
-    async fn fetch_snapshot(&self, _report_id: &str) -> Result<Snapshot> {
+    async fn fetch_snapshots(&self, _report_id: &str) -> Result<Vec<Snapshot>> {
         todo!()
     }
 }

crates/quark/src/impl/generic/mod.rs

@@ -26,4 +26,5 @@ pub mod users {
 
 pub mod safety {
     pub mod report;
+    pub mod snapshot;
 }

crates/quark/src/impl/generic/safety/report.rs

@@ -1,9 +1,30 @@
-use crate::{models::report::PartialReport, models::Report, Database, Result};
+use iso8601_timestamp::Timestamp;
+
+use crate::{
+    models::report::PartialReport,
+    models::{report::ReportStatus, Report},
+    Database, Result,
+};
 
 impl Report {
     /// Update report data
     pub async fn update(&mut self, db: &Database, partial: PartialReport) -> Result<()> {
         self.apply_options(partial.clone());
+
+        match &mut self.status {
+            ReportStatus::Created {} => {}
+            ReportStatus::Rejected { closed_at, .. } => {
+                if closed_at.is_none() {
+                    closed_at.replace(Timestamp::now_utc());
+                }
+            }
+            ReportStatus::Resolved { closed_at } => {
+                if closed_at.is_none() {
+                    closed_at.replace(Timestamp::now_utc());
+                }
+            }
+        }
+
         db.update_report(&self.id, &partial).await
     }
 }

crates/quark/src/impl/generic/safety/snapshot.rs

@@ -0,0 +1,88 @@
+use crate::{
+    models::{
+        message::{MessageFilter, MessageQuery, MessageSort, MessageTimePeriod},
+        snapshot::SnapshotContent,
+        Message, Server, User,
+    },
+    Database, Result,
+};
+
+impl SnapshotContent {
+    pub async fn generate_from_message(
+        db: &Database,
+        message: Message,
+    ) -> Result<(SnapshotContent, Vec<String>)> {
+        // Collect message attachments
+        let files = message
+            .attachments
+            .as_ref()
+            .map(|attachments| attachments.iter().map(|x| x.id.to_string()).collect())
+            .unwrap_or_default();
+
+        // Collect prior context
+        let prior_context = db
+            .fetch_messages(MessageQuery {
+                filter: MessageFilter {
+                    channel: Some(message.channel.to_string()),
+                    ..Default::default()
+                },
+                limit: Some(15),
+                time_period: MessageTimePeriod::Absolute {
+                    before: Some(message.id.to_string()),
+                    after: None,
+                    sort: Some(MessageSort::Latest),
+                },
+            })
+            .await?;
+
+        // Collect leading context
+        let leading_context = db
+            .fetch_messages(MessageQuery {
+                filter: MessageFilter {
+                    channel: Some(message.channel.to_string()),
+                    ..Default::default()
+                },
+                limit: Some(15),
+                time_period: MessageTimePeriod::Absolute {
+                    before: None,
+                    after: Some(message.id.to_string()),
+                    sort: Some(MessageSort::Oldest),
+                },
+            })
+            .await?;
+
+        Ok((
+            SnapshotContent::Message {
+                message,
+                prior_context,
+                leading_context,
+            },
+            files,
+        ))
+    }
+
+    pub fn generate_from_server(server: Server) -> Result<(SnapshotContent, Vec<String>)> {
+        // Collect server's icon and banner
+        let files = [&server.icon, &server.banner]
+            .iter()
+            .filter_map(|x| x.as_ref().map(|x| x.id.to_string()))
+            .collect();
+
+        Ok((SnapshotContent::Server(server), files))
+    }
+
+    pub fn generate_from_user(user: User) -> Result<(SnapshotContent, Vec<String>)> {
+        // Collect user's avatar and profile background
+        let files = [
+            user.avatar.as_ref(),
+            user.profile
+                .as_ref()
+                .and_then(|profile| profile.background.as_ref()),
+        ]
+        .iter()
+        .filter_map(|x| x.as_ref().map(|x| x.id.to_string()))
+        .collect();
+
+        Ok((SnapshotContent::User(user), files))
+    }
+}

crates/quark/src/impl/generic/users/user.rs

@@ -33,6 +33,7 @@ impl User {
             id: self.id.clone(),
             data: partial,
             clear: remove,
+            event_id: Some(ulid::Ulid::new().to_string()),
         }
         .p_user(self.id.clone(), db)
         .await;

crates/quark/src/impl/mongo/safety/snapshot.rs

@@ -11,8 +11,8 @@ impl AbstractSnapshot for MongoDb {
         self.insert_one(COL, snapshot).await.map(|_| ())
     }
 
-    async fn fetch_snapshot(&self, report_id: &str) -> Result<Snapshot> {
-        self.find_one(
+    async fn fetch_snapshots(&self, report_id: &str) -> Result<Vec<Snapshot>> {
+        self.find(
             COL,
             doc! {
                 "report_id": report_id

crates/quark/src/models/safety/report.rs

@@ -1,3 +1,5 @@
+use iso8601_timestamp::Timestamp;
+use rocket::FromFormField;
 use serde::{Deserialize, Serialize};
 
 /// Reason for reporting content (message or server)
@@ -6,16 +8,41 @@ pub enum ContentReportReason {
     /// No reason has been specified
     NoneSpecified,
 
-    /// Blatantly illegal content
+    /// Illegal content catch-all reason
     Illegal,
 
+    /// Selling or facilitating use of drugs or other illegal goods
+    IllegalGoods,
+
+    /// Extortion or blackmail
+    IllegalExtortion,
+
+    /// Revenge or child pornography
+    IllegalPornography,
+
+    /// Illegal hacking activity
+    IllegalHacking,
+
+    /// Extreme violence, gore, or animal cruelty
+    /// With exception to violence potrayed in media / creative arts
+    ExtremeViolence,
+
     /// Content that promotes harm to others / self
     PromotesHarm,
 
+    /// Unsolicited advertisements
+    UnsolicitedSpam,
+
+    /// This is a raid
+    Raid,
+
     /// Spam or platform abuse
     SpamAbuse,
 
-    /// Distribution of malware
+    /// Scams or fraud
+    ScamsFraud,
+
+    /// Distribution of malware or malicious links
     Malware,
 
     /// Harassment or abuse targeted at another user
@@ -28,6 +55,9 @@ pub enum UserReportReason {
     /// No reason has been specified
     NoneSpecified,
 
+    /// Unsolicited advertisements
+    UnsolicitedSpam,
+
     /// User is sending spam or otherwise abusing the platform
     SpamAbuse,
 
@@ -68,6 +98,8 @@ pub enum ReportedContent {
         id: String,
         /// Reason for reporting a user
         report_reason: UserReportReason,
+        /// Message context
+        message_id: Option<String>,
     },
 }
 
@@ -79,10 +111,26 @@ pub enum ReportStatus {
     Created {},
 
     /// Report was rejected
-    Rejected { rejection_reason: String },
+    Rejected {
+        rejection_reason: String,
+        closed_at: Option<Timestamp>,
+    },
 
     /// Report was actioned and resolved
-    Resolved {},
+    Resolved { closed_at: Option<Timestamp> },
+}
+
+/// Just the status of the report
+#[derive(Serialize, Deserialize, JsonSchema, Debug, Clone, FromFormField)]
+pub enum ReportStatusString {
+    /// Report is waiting for triage / action
+    Created,
+
+    /// Report was rejected
+    Rejected,
+
+    /// Report was actioned and resolved
+    Resolved,
 }
 
 /// User-generated platform moderation report.

crates/quark/src/tasks/ack.rs

@@ -2,8 +2,8 @@
 use crate::Database;
 
 use deadqueue::limited::Queue;
-use std::{collections::HashMap, time::Duration};
 use once_cell::sync::Lazy;
+use std::{collections::HashMap, time::Duration};
 
 use super::DelayedTask;
 
@@ -95,7 +95,7 @@ pub async fn worker(db: Database) {
         }) = Q.try_pop()
         {
             let key = (user, channel);
-            if let Some(mut task) = tasks.get_mut(&key) {
+            if let Some(task) = tasks.get_mut(&key) {
                 task.delay();
 
                 match &mut event {

crates/quark/src/tasks/last_message_id.rs

@@ -2,8 +2,8 @@
 use crate::{models::channel::PartialChannel, Database};
 
 use deadqueue::limited::Queue;
-use std::{collections::HashMap, time::Duration};
 use once_cell::sync::Lazy;
+use std::{collections::HashMap, time::Duration};
 
 use super::DelayedTask;
 
@@ -73,7 +73,7 @@ pub async fn worker(db: Database) {
 
         // Queue incoming tasks.
         while let Some(Data { channel, id, is_dm }) = Q.try_pop() {
-            if let Some(mut task) = tasks.get_mut(&channel) {
+            if let Some(task) = tasks.get_mut(&channel) {
                 task.data.id = id;
                 task.delay();
             } else {

crates/quark/src/traits/safety/snapshot.rs

@@ -6,6 +6,6 @@ pub trait AbstractSnapshot: Sync + Send {
     /// Insert a new snapshot into the database
     async fn insert_snapshot(&self, snapshot: &Snapshot) -> Result<()>;
 
-    /// Fetch a snapshot by a report's id
-    async fn fetch_snapshot(&self, report_id: &str) -> Result<Snapshot>;
+    /// Fetch a snapshots by a report's id
+    async fn fetch_snapshots(&self, report_id: &str) -> Result<Vec<Snapshot>>;
 }