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,8 +11,9 @@ pub async fn req(user: User, target: Ref) -> Result<JsonValue> {
         .with_channel(&target)
         .for_channel()
         .await?;
+
     if !perm.get_view() {
-        Err(Error::LabelMe)?
+        Err(Error::MissingPermission)?
     }
 
     Ok(json!(target))

src/routes/channels/group_add_member.rs

@@ -15,8 +15,9 @@ pub async fn req(user: User, target: Ref, member: Ref) -> Result<()> {
         .with_channel(&channel)
         .for_channel()
         .await?;
-    if !perm.get_view() {
-        Err(Error::LabelMe)?
+
+    if !perm.get_invite_others() {
+        Err(Error::MissingPermission)?
     }
 
     if let Channel::Group { id, recipients, .. } = &channel {
@@ -52,16 +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(),
-            format!("<@{}> added <@{}> to the group.", user.id, member.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?;