src/routes/channels/channel_edit.rs

+use crate::notifications::events::ClientboundNotification;
+use crate::util::result::{Error, Result};
+use crate::{database::*, notifications::events::RemoveChannelField};
+
+use mongodb::bson::{doc, to_document};
+use rocket_contrib::json::Json;
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+#[derive(Validate, Serialize, Deserialize)]
+pub struct Data {
+    #[validate(length(min = 1, max = 32))]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    name: Option<String>,
+    #[validate(length(min = 0, max = 1024))]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    description: Option<String>,
+    #[validate(length(min = 1, max = 128))]
+    icon: Option<String>,
+    remove: Option<RemoveChannelField>,
+}
+
+#[patch("/<target>", data = "<data>")]
+pub async fn req(user: User, target: Ref, data: Json<Data>) -> Result<()> {
+    let data = data.into_inner();
+    data.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    if data.name.is_none()
+        && data.description.is_none()
+        && data.icon.is_none()
+        && data.remove.is_none()
+    {
+        return Ok(());
+    }
+
+    let target = target.fetch_channel().await?;
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&target)
+        .for_channel()
+        .await?;
+
+    if !perm.get_manage_channel() {
+        Err(Error::MissingPermission)?
+    }
+
+    match &target {
+        Channel::Group { id, icon, .. }
+        | Channel::TextChannel { id, icon, .. }
+        | Channel::VoiceChannel { id, icon, .. } => {
+            let mut set = doc! {};
+            let mut unset = doc! {};
+
+            let mut remove_icon = false;
+            if let Some(remove) = &data.remove {
+                match remove {
+                    RemoveChannelField::Icon => {
+                        unset.insert("icon", 1);
+                        remove_icon = true;
+                    }
+                    RemoveChannelField::Description => {
+                        unset.insert("description", 1);
+                    }
+                }
+            }
+
+            if let Some(name) = &data.name {
+                set.insert("name", name);
+            }
+
+            if let Some(description) = &data.description {
+                set.insert("description", description);
+            }
+
+            if let Some(attachment_id) = &data.icon {
+                let attachment =
+                    File::find_and_use(&attachment_id, "icons", "object", target.id()).await?;
+                set.insert(
+                    "icon",
+                    to_document(&attachment).map_err(|_| Error::DatabaseError {
+                        operation: "to_document",
+                        with: "attachment",
+                    })?,
+                );
+
+                remove_icon = true;
+            }
+
+            let mut operations = doc! {};
+            if set.len() > 0 {
+                operations.insert("$set", &set);
+            }
+
+            if unset.len() > 0 {
+                operations.insert("$unset", unset);
+            }
+
+            if operations.len() > 0 {
+                get_collection("channels")
+                    .update_one(doc! { "_id": &id }, operations, None)
+                    .await
+                    .map_err(|_| Error::DatabaseError {
+                        operation: "update_one",
+                        with: "channel",
+                    })?;
+            }
+
+            ClientboundNotification::ChannelUpdate {
+                id: id.clone(),
+                data: json!(set),
+                clear: data.remove,
+            }
+            .publish(id.clone());
+
+            if let Channel::Group { .. } = &target {
+                if let Some(name) = data.name {
+                    Content::SystemMessage(SystemMessage::ChannelRenamed {
+                        name,
+                        by: user.id.clone(),
+                    })
+                    .send_as_system(&target)
+                    .await
+                    .ok();
+                }
+
+                if let Some(_) = data.description {
+                    Content::SystemMessage(SystemMessage::ChannelDescriptionChanged {
+                        by: user.id.clone(),
+                    })
+                    .send_as_system(&target)
+                    .await
+                    .ok();
+                }
+
+                if let Some(_) = data.icon {
+                    Content::SystemMessage(SystemMessage::ChannelIconChanged { by: user.id })
+                        .send_as_system(&target)
+                        .await
+                        .ok();
+                }
+            }
+
+            if remove_icon {
+                if let Some(old_icon) = icon {
+                    old_icon.delete().await?;
+                }
+            }
+
+            Ok(())
+        }
+        _ => Err(Error::InvalidOperation),
+    }
+}

src/routes/channels/fetch_channel.rs → src/routes/channels/channel_fetch.rs

@@ -11,6 +11,7 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
         .with_channel(&target)
         .for_channel()
         .await?;
+
     if !perm.get_view() {
         Err(Error::MissingPermission)?
     }

src/routes/channels/edit_channel.rs

-use crate::database::*;
-use crate::notifications::events::ClientboundNotification;
-use crate::util::result::{Error, Result};
-
-use mongodb::bson::{doc, to_document};
-use rocket_contrib::json::Json;
-use serde::{Deserialize, Serialize};
-use validator::Validate;
-
-#[derive(Validate, Serialize, Deserialize)]
-pub struct Data {
-    #[validate(length(min = 1, max = 32))]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    name: Option<String>,
-    #[validate(length(min = 0, max = 1024))]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    description: Option<String>,
-}
-
-#[patch("/<target>", data = "<info>")]
-pub async fn req(user: User, target: Ref, info: Json<Data>) -> Result<()> {
-    info.validate()
-        .map_err(|error| Error::FailedValidation { error })?;
-
-    if info.name.is_none() && info.description.is_none() {
-        return Ok(());
-    }
-
-    let target = target.fetch_channel().await?;
-    let perm = permissions::PermissionCalculator::new(&user)
-        .with_channel(&target)
-        .for_channel()
-        .await?;
-
-    if !perm.get_manage_channel() {
-        Err(Error::MissingPermission)?
-    }
-
-    match &target {
-        Channel::Group { id, .. } => {
-            get_collection("channels")
-            .update_one(
-                doc! { "_id": &id },
-                doc! { "$set": to_document(&info.0).map_err(|_| Error::DatabaseError { operation: "to_document", with: "data" })? },
-                None
-            )
-            .await
-            .map_err(|_| Error::DatabaseError { operation: "update_one", with: "channel" })?;
-
-            ClientboundNotification::ChannelUpdate {
-                id: id.clone(),
-                data: json!(info.0),
-            }
-            .publish(id.clone())
-            .await
-            .ok();
-
-            if let Some(name) = &info.name {
-                Message::create(
-                    "00000000000000000000000000".to_string(),
-                    id.clone(),
-                    Content::SystemMessage(SystemMessage::ChannelRenamed {
-                        name: name.clone(),
-                        by: user.id,
-                    }),
-                )
-                .publish(&target)
-                .await
-                .ok();
-            }
-
-            Ok(())
-        }
-        _ => Err(Error::InvalidOperation),
-    }
-}

src/routes/channels/group_add_member.rs

@@ -15,7 +15,8 @@ pub async fn req(user: User, target: Ref, member: Ref) -> Result<()> {
         .with_channel(&channel)
         .for_channel()
         .await?;
-    if !perm.get_view() {
+
+    if !perm.get_invite_others() {
         Err(Error::MissingPermission)?
     }
 
@@ -52,19 +53,13 @@ pub async fn req(user: User, target: Ref, member: Ref) -> Result<()> {
             id: id.clone(),
             user: member.id.clone(),
         }
-        .publish(id.clone())
-        .await
-        .ok();
+        .publish(id.clone());
 
-        Message::create(
-            "00000000000000000000000000".to_string(),
-            id.clone(),
-            Content::SystemMessage(SystemMessage::UserAdded {
-                id: member.id,
-                by: user.id,
-            }),
-        )
-        .publish(&channel)
+        Content::SystemMessage(SystemMessage::UserAdded {
+            id: member.id,
+            by: user.id,
+        })
+        .send_as_system(&channel)
         .await
         .ok();
 

src/routes/channels/group_create.rs

@@ -24,6 +24,7 @@ pub struct Data {
 
 #[post("/create", data = "<info>")]
 pub async fn req(user: User, info: Json<Data>) -> Result<JsonValue> {
+    let info = info.into_inner();
     info.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
@@ -37,8 +38,11 @@ pub async fn req(user: User, info: Json<Data>) -> Result<JsonValue> {
     }
 
     for target in &set {
-        if get_relationship(&user, target) != RelationshipStatus::Friend {
-            Err(Error::NotFriends)?
+        match get_relationship(&user, target) {
+            RelationshipStatus::Friend | RelationshipStatus::User => {}
+            _ => {
+                return Err(Error::NotFriends);
+            }
         }
     }
 
@@ -62,15 +66,14 @@ pub async fn req(user: User, info: Json<Data>) -> Result<JsonValue> {
     let id = Ulid::new().to_string();
     let channel = Channel::Group {
         id,
-        nonce: Some(info.nonce.clone()),
-        name: info.name.clone(),
-        description: info
-            .description
-            .clone()
-            .unwrap_or_else(|| "A group.".to_string()),
+        nonce: Some(info.nonce),
+        name: info.name,
+        description: info.description,
         owner: user.id,
         recipients: set.into_iter().collect::<Vec<String>>(),
+        icon: None,
         last_message: None,
+        permissions: None
     };
 
     channel.clone().publish().await?;

src/routes/channels/group_remove_member.rs

@@ -49,19 +49,13 @@ pub async fn req(user: User, target: Ref, member: Ref) -> Result<()> {
             id: id.clone(),
             user: member.id.clone(),
         }
-        .publish(id.clone())
-        .await
-        .ok();
+        .publish(id.clone());
 
-        Message::create(
-            "00000000000000000000000000".to_string(),
-            id.clone(),
-            Content::SystemMessage(SystemMessage::UserRemove {
-                id: member.id,
-                by: user.id,
-            }),
-        )
-        .publish(&channel)
+        Content::SystemMessage(SystemMessage::UserRemove {
+            id: member.id,
+            by: user.id,
+        })
+        .send_as_system(&channel)
         .await
         .ok();
 

src/routes/channels/invite_create.rs

+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use mongodb::bson::doc;
+use nanoid::nanoid;
+use rocket_contrib::json::JsonValue;
+
+lazy_static! {
+    static ref ALPHABET: [char; 54] = [
+        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+        'J', 'K', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
+        'e', 'f', 'g', 'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'y', 'z'
+    ];
+}
+
+#[post("/<target>/invites")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    let target = target.fetch_channel().await?;
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&target)
+        .for_channel()
+        .await?;
+
+    if !perm.get_invite_others() {
+        return Err(Error::MissingPermission);
+    }
+
+    let code = nanoid!(8, &*ALPHABET);
+    match &target {
+        Channel::Group { .. } => {
+            unimplemented!()
+        }
+        Channel::TextChannel { id, server, .. }
+        | Channel::VoiceChannel { id, server, .. } => {
+            Invite::Server {
+                code: code.clone(),
+                creator: user.id,
+                server: server.clone(),
+                channel: id.clone(),
+            }
+            .save()
+            .await?;
+
+            Ok(json!({ "code": code }))
+        }
+        _ => Err(Error::InvalidOperation),
+    }
+}

src/routes/channels/members_fetch.rs

+use crate::database::*;
+use crate::util::result::{Error, Result};
+
+use rocket_contrib::json::JsonValue;
+
+#[get("/<target>/members")]
+pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
+    let target = target.fetch_channel().await?;
+
+    let perm = permissions::PermissionCalculator::new(&user)
+        .with_channel(&target)
+        .for_channel()
+        .await?;
+    if !perm.get_view() {
+        Err(Error::MissingPermission)?
+    }
+
+    if let Channel::Group { recipients, .. } = target {
+        Ok(json!(user.fetch_multiple_users(recipients).await?))
+    } else {
+        Err(Error::InvalidOperation)
+    }
+}

src/routes/channels/message_delete.rs

@@ -6,6 +6,7 @@ use mongodb::bson::doc;
 #[delete("/<target>/messages/<msg>")]
 pub async fn req(user: User, target: Ref, msg: Ref) -> Result<()> {
     let channel = target.fetch_channel().await?;
+    channel.has_messaging()?;
 
     let perm = permissions::PermissionCalculator::new(&user)
         .with_channel(&channel)

src/routes/channels/message_edit.rs

@@ -2,7 +2,7 @@ use crate::database::*;
 use crate::util::result::{Error, Result};
 
 use chrono::Utc;
-use mongodb::bson::{doc, Bson, DateTime};
+use mongodb::bson::{doc, Bson, DateTime, Document};
 use rocket_contrib::json::Json;
 use serde::{Deserialize, Serialize};
 use validator::Validate;
@@ -19,6 +19,8 @@ pub async fn req(user: User, target: Ref, msg: Ref, edit: Json<Data>) -> Result<
         .map_err(|error| Error::FailedValidation { error })?;
 
     let channel = target.fetch_channel().await?;
+    channel.has_messaging()?;
+
     let perm = permissions::PermissionCalculator::new(&user)
         .with_channel(&channel)
         .for_channel()
@@ -27,22 +29,41 @@ pub async fn req(user: User, target: Ref, msg: Ref, edit: Json<Data>) -> Result<
         Err(Error::MissingPermission)?
     }
 
-    let message = msg.fetch_message(&channel).await?;
+    let mut message = msg.fetch_message(&channel).await?;
     if message.author != user.id {
         Err(Error::CannotEditMessage)?
     }
 
     let edited = Utc::now();
+    let mut set = doc! {
+        "content": &edit.content,
+        "edited": Bson::DateTime(edited)
+    };
+
+    message.content = Content::Text(edit.content.clone());
+    let mut update = json!({ "content": edit.content, "edited": DateTime(edited) });
+
+    if let Some(embeds) = &message.embeds {
+        let new_embeds: Vec<Document> = vec![];
+
+        for embed in embeds {
+            match embed {
+                Embed::Website(_) | Embed::Image(_) | Embed::None => {} // Otherwise push to new_embeds.
+            }
+        }
+
+        let obj = update.as_object_mut().unwrap();
+        obj.insert("embeds".to_string(), json!(new_embeds).0);
+        set.insert("embeds", new_embeds);
+    }
+
     get_collection("messages")
         .update_one(
             doc! {
                 "_id": &message.id
             },
             doc! {
-                "$set": {
-                    "content": &edit.content,
-                    "edited": Bson::DateTime(edited)
-                }
+                "$set": set
             },
             None,
         )
@@ -52,7 +73,5 @@ pub async fn req(user: User, target: Ref, msg: Ref, edit: Json<Data>) -> Result<
             with: "message",
         })?;
 
-    message
-        .publish_update(json!({ "content": edit.content, "edited": DateTime(edited) }))
-        .await
+    message.publish_update(update).await
 }

src/routes/channels/message_fetch.rs

@@ -6,6 +6,7 @@ use rocket_contrib::json::JsonValue;
 #[get("/<target>/messages/<msg>")]
 pub async fn req(user: User, target: Ref, msg: Ref) -> Result<JsonValue> {
     let channel = target.fetch_channel().await?;
+    channel.has_messaging()?;
 
     let perm = permissions::PermissionCalculator::new(&user)
         .with_channel(&channel)

src/routes/channels/message_query_stale.rs

@@ -18,6 +18,7 @@ pub async fn req(user: User, target: Ref, data: Json<Options>) -> Result<JsonVal
     }
 
     let target = target.fetch_channel().await?;
+    target.has_messaging()?;
 
     let perm = permissions::PermissionCalculator::new(&user)
         .with_channel(&target)

src/routes/channels/mod.rs

 use rocket::Route;
 
-mod delete_channel;
-mod edit_channel;
-mod fetch_channel;
+mod channel_ack;
+mod channel_delete;
+mod channel_edit;
+mod channel_fetch;
+mod members_fetch;
 mod group_add_member;
 mod group_create;
 mod group_remove_member;
-mod join_call;
+mod invite_create;
+mod voice_join;
 mod message_delete;
 mod message_edit;
 mod message_fetch;
 mod message_query;
+mod message_search;
 mod message_query_stale;
 mod message_send;
+mod permissions_set;
+mod permissions_set_default;
 
 pub fn routes() -> Vec<Route> {
     routes![
-        fetch_channel::req,
-        delete_channel::req,
-        edit_channel::req,
+        channel_ack::req,
+        channel_fetch::req,
+        members_fetch::req,
+        channel_delete::req,
+        channel_edit::req,
+        invite_create::req,
         message_send::req,
         message_query::req,
+        message_search::req,
         message_query_stale::req,
         message_fetch::req,
         message_edit::req,
@@ -28,6 +38,8 @@ pub fn routes() -> Vec<Route> {
         group_create::req,
         group_add_member::req,
         group_remove_member::req,
-        join_call::req,
+        voice_join::req,
+        permissions_set::req,
+        permissions_set_default::req,
     ]
 }

src/routes/channels/join_call.rs → src/routes/channels/voice_join.rs

@@ -17,6 +17,13 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
     }
 
     let target = target.fetch_channel().await?;
+    match target {
+        Channel::SavedMessages { .. } | Channel::TextChannel { .. } => {
+            return Err(Error::CannotJoinCall)
+        }
+        _ => {}
+    }
+
     let perm = permissions::PermissionCalculator::new(&user)
         .with_channel(&target)
         .for_channel()