feat: implement missing permission syncs

crates/core/database/src/events/client.rs

@@ -254,6 +254,11 @@ pub enum EventV1 {
         id: String,
         user: String,
     },
+    VoiceChannelMove {
+        user: String,
+        from: String,
+        to: String,
+    },
     UserVoiceStateUpdate {
         id: String,
         channel_id: String,

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

@@ -1,15 +1,20 @@
 
-use redis_kiss::{get_connection, redis::Pipeline, AsyncCommands};
+use livekit_protocol::ParticipantPermission;
-use crate::models::{Channel, User};
+use redis_kiss::{get_connection as _get_connection, Conn, redis::Pipeline, AsyncCommands};
+use crate::{events::client::EventV1, models::{Channel, User}, util::{permissions::DatabasePermissionQuery, reference::Reference}, Database, Role, Server};
 use revolt_models::v0::{self, PartialUserVoiceState, UserVoiceState};
-use revolt_permissions::{ChannelPermission, PermissionValue};
+use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
 use revolt_result::{create_error, Result, ToRevoltError};
 
 mod voice_client;
 pub use voice_client::VoiceClient;
 
+async fn get_connection() -> Result<Conn> {
+    _get_connection().await.to_internal_error()
+}
+
 pub async fn raise_if_in_voice(user: &User, target: &str) -> Result<()> {
-    let mut conn = get_connection().await.to_internal_error()?;
+    let mut conn = get_connection().await?;
 
     if user.bot.is_some()
     // bots can be in as many voice channels as it wants so we just check if its already connected to the one its trying to connect to
@@ -30,11 +35,27 @@ pub async fn raise_if_in_voice(user: &User, target: &str) -> Result<()> {
     }
 }
 
+pub async fn get_user_voice_channels(user_id: &str) -> Result<Vec<String>> {
+    get_connection()
+        .await?
+        .smembers(format!("vc:{user_id}"))
+        .await
+        .to_internal_error()
+}
+
+pub async fn is_in_voice_channel(user_id: &str, channel_id: &str) -> Result<bool> {
+    get_connection()
+        .await?
+        .sismember(format!("vc:{}", user_id), channel_id)
+        .await
+        .to_internal_error()
+}
+
 pub async fn get_user_voice_channel_in_server(
     user_id: &str,
     server_id: &str,
 ) -> Result<Option<String>> {
-    let mut conn = get_connection().await.to_internal_error()?;
+    let mut conn = get_connection().await?;
 
     let unique_key = format!("{}:{}", user_id, server_id);
 
@@ -89,7 +110,7 @@ pub async fn create_voice_state(
             voice_state.screensharing,
         )
         .set(format!("camera:{unique_key}"), voice_state.camera)
-        .query_async(&mut get_connection().await.to_internal_error()?.into_inner())
+        .query_async(&mut get_connection().await?.into_inner())
         .await
         .to_internal_error()?;
 
@@ -113,7 +134,7 @@ pub async fn delete_voice_state(
             format!("camera:{unique_key}"),
             unique_key.clone(),
         ])
-        .query_async(&mut get_connection().await.to_internal_error()?.into_inner())
+        .query_async(&mut get_connection().await?.into_inner())
         .await
         .to_internal_error()?;
 
@@ -179,7 +200,7 @@ pub async fn update_voice_state(
     }
 
     pipeline
-        .query_async(&mut get_connection().await.to_internal_error()?.into_inner())
+        .query_async(&mut get_connection().await?.into_inner())
         .await
         .to_internal_error()?;
 
@@ -188,8 +209,7 @@ pub async fn update_voice_state(
 
 pub async fn get_voice_channel_members(channel_id: &str) -> Result<Vec<String>> {
     get_connection()
-        .await
+        .await?
-        .to_internal_error()?
         .smembers::<_, Vec<String>>(format!("vc_members:{}", channel_id))
         .await
         .to_internal_error()
@@ -203,8 +223,7 @@ pub async fn get_voice_state(
     let unique_key = format!("{}:{user_id}", server_id.unwrap_or(channel_id));
 
     let (is_publishing, is_receiving, screensharing, camera) = get_connection()
-        .await
+        .await?
-        .to_internal_error()?
         .mget::<_, (Option<bool>, Option<bool>, Option<bool>, Option<bool>)>(&[
             format!("is_publishing:{unique_key}"),
             format!("is_receiving:{unique_key}"),
@@ -257,3 +276,85 @@ pub async fn get_channel_voice_state(channel: &Channel) -> Result<Option<v0::Cha
         Ok(None)
     }
 }
+
+pub async fn move_user(user: &str, from: &str, to: &str) -> Result<()> {
+    get_connection()
+        .await?
+        .smove(
+            format!("vc-members-{from}"),
+            format!("vc-members-{to}"),
+            user,
+        )
+        .await
+        .to_internal_error()?;
+
+    Ok(())
+}
+
+pub async fn sync_voice_permissions(db: &Database, voice_client: &VoiceClient, channel: &Channel, server: Option<&Server>, role_id: Option<&str>) -> Result<()> {
+
+    for user_id in get_voice_channel_members(channel.id()).await? {
+        let user = Reference::from_unchecked(user_id.clone()).as_user(db).await?;
+
+        sync_user_voice_permissions(db, voice_client, &user, channel, server, role_id).await?;
+    };
+
+    Ok(())
+}
+
+pub async fn sync_user_voice_permissions(db: &Database, voice_client: &VoiceClient, user: &User, channel: &Channel, server: Option<&Server>, role_id: Option<&str>) -> Result<()> {
+    let channel_id = channel.id();
+    let server_id: Option<&str> = server.as_ref().map(|s| s.id.as_str());
+
+    let member = match server_id {
+        Some(server_id) => Some(Reference::from_unchecked(user.id.clone()).as_member(db, server_id).await?),
+        None => None
+    };
+
+    if role_id.is_none_or(|role_id| member.as_ref().is_none_or(|member| member.roles.iter().any(|r| r == role_id))) {
+        let voice_state = get_voice_state(channel_id, server_id, &user.id).await?.unwrap();
+
+        let mut query = DatabasePermissionQuery::new(db, user)
+            .channel(channel);
+
+        if let (Some(server), Some(member)) = (server, member.as_ref()) {
+                query = query.member(member).server(server)
+        }
+
+        let permissions = calculate_channel_permissions(&mut query).await;
+
+        let mut update_event = PartialUserVoiceState {
+            id: Some(user.id.clone()),
+            ..Default::default()
+        };
+
+        let before = update_event.clone();
+
+        let can_video = permissions.has_channel_permission(ChannelPermission::Video);
+        let can_speak = permissions.has_channel_permission(ChannelPermission::Speak);
+        let can_listen = permissions.has_channel_permission(ChannelPermission::Listen);
+
+        update_event.camera = voice_state.camera.then_some(can_video);
+        update_event.screensharing = voice_state.screensharing.then_some(can_video);
+        update_event.is_publishing = voice_state.is_publishing.then_some(can_speak);
+
+        update_voice_state(channel_id, server_id, &user.id, &update_event).await?;
+
+        voice_client.update_permissions(user, channel_id, ParticipantPermission {
+            can_subscribe: can_listen,
+            can_publish: can_speak,
+            can_publish_data: can_speak,
+            ..Default::default()
+        }).await?;
+
+        if update_event != before {
+            EventV1::UserVoiceStateUpdate {
+                id: user.id.clone(),
+                channel_id: channel_id.to_string(),
+                data: update_event
+            }.p(channel_id.to_string()).await;
+        };
+    };
+
+    Ok(())
+}

crates/core/database/src/voice/voice_client.rs

@@ -105,4 +105,10 @@ impl VoiceClient {
             .await
             .to_internal_error()
     }
+
+    pub async fn remove_user(&self, user: &User, channel_id: &str) -> Result<()> {
+        self.rooms.remove_participant(channel_id, &user.id)
+            .await
+            .to_internal_error()
+    }
 }

crates/core/result/src/lib.rs

@@ -220,11 +220,10 @@ pub trait ToRevoltError<T> {
 impl<T, E: std::fmt::Debug> ToRevoltError<T> for Result<T, E> {
     #[track_caller]
     fn to_internal_error(self) -> Result<T, Error> {
-        self
-        .inspect_err(|e| log::error!("{e:?}"))
-        .map_err(|_| {
         let loc = Location::caller();
 
+        self
+            .map_err(|_| {
                 Error {
                     error_type: ErrorType::InternalError,
                     location: format!("{}:{}:{}", loc.file(), loc.line(), loc.column())
@@ -236,9 +235,9 @@ impl<T, E: std::fmt::Debug> ToRevoltError<T> for Result<T, E> {
 impl<T> ToRevoltError<T> for Option<T> {
     #[track_caller]
     fn to_internal_error(self) -> Result<T, Error> {
-        self.ok_or_else(|| {
         let loc = Location::caller();
 
+        self.ok_or_else(|| {
             Error {
                 error_type: ErrorType::InternalError,
                 location: format!("{}:{}:{}", loc.file(), loc.line(), loc.column())

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

@@ -1,6 +1,5 @@
 use revolt_database::{
-    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    util::{permissions::DatabasePermissionQuery, reference::Reference}, voice::{delete_voice_state, get_voice_channel_members, VoiceClient}, Channel, Database, PartialChannel, User, AMQP
-    Channel, Database, PartialChannel, User, AMQP,
 };
 use revolt_models::v0;
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
@@ -15,6 +14,7 @@ use rocket_empty::EmptyResponse;
 #[delete("/<target>?<options..>")]
 pub async fn delete(
     db: &State<Database>,
+    voice_client: &State<VoiceClient>,
     amqp: &State<AMQP>,
     user: User,
     target: Reference,
@@ -27,7 +27,7 @@ pub async fn delete(
     permissions.throw_if_lacking_channel_permission(ChannelPermission::ViewChannel)?;
 
     match &channel {
-        Channel::SavedMessages { .. } => Err(create_error!(NoEffect)),
+        Channel::SavedMessages { .. } => Err(create_error!(NoEffect))?,
         Channel::DirectMessage { .. } => channel
             .update(
                 db,
@@ -37,8 +37,7 @@ pub async fn delete(
                 },
                 vec![],
             )
-            .await
+            .await?,
-            .map(|_| EmptyResponse),
         Channel::Group { .. } => channel
             .remove_user_from_group(
                 db,
@@ -47,13 +46,21 @@ pub async fn delete(
                 None,
                 options.leave_silently.unwrap_or_default(),
             )
-            .await
+            .await?,
-            .map(|_| EmptyResponse),
         Channel::TextChannel { .. } | Channel::VoiceChannel { .. } => {
             permissions.throw_if_lacking_channel_permission(ChannelPermission::ManageChannel)?;
-            channel.delete(db).await.map(|_| EmptyResponse)
+            channel.delete(db).await?
-        }
         }
+    };
+
+    for user_id in get_voice_channel_members(channel.id()).await? {
+        let user = Reference::from_unchecked(user_id).as_user(db).await?;
+
+        voice_client.remove_user(&user, channel.id()).await?;
+        delete_voice_state(channel.id(), channel.server().as_deref(), &user.id).await?;
+    };
+
+    Ok(EmptyResponse)
 }
 
 #[cfg(test)]

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

@@ -1,4 +1,4 @@
-use revolt_database::{util::reference::Reference, Channel, Database, User, AMQP};
+use revolt_database::{util::reference::Reference, voice::{delete_voice_state, is_in_voice_channel, raise_if_in_voice, VoiceClient}, Channel, Database, User, AMQP};
 use revolt_permissions::ChannelPermission;
 use revolt_result::{create_error, Result};
 
@@ -12,6 +12,7 @@ use rocket_empty::EmptyResponse;
 #[delete("/<target>/recipients/<member>")]
 pub async fn remove_member(
     db: &State<Database>,
+    voice_client: &State<VoiceClient>,
     amqp: &State<AMQP>,
     user: User,
     target: Reference,
@@ -23,10 +24,7 @@ pub async fn remove_member(
 
     let channel = target.as_channel(db).await?;
 
-    match &channel {
+    if let Channel::Group { owner, recipients, .. } = &channel {
-        Channel::Group {
-            owner, recipients, ..
-        } => {
         if &user.id != owner {
             return Err(create_error!(MissingPermission {
                 permission: ChannelPermission::ManageChannel.to_string()
@@ -44,11 +42,17 @@ pub async fn remove_member(
 
         channel
             .remove_user_from_group(db, amqp, &member, Some(&user.id), false)
-                .await
+            .await?;
-                .map(|_| EmptyResponse)
+    } else {
-        }
+        return Err(create_error!(InvalidOperation))
-        _ => Err(create_error!(InvalidOperation)),
+    };
-    }
+
+    if is_in_voice_channel(&user.id, channel.id()).await? {
+        voice_client.remove_user(&user, channel.id()).await?;
+        delete_voice_state(channel.id(), None, &user.id).await?;
+    };
+
+    Ok(EmptyResponse)
 }
 
 #[cfg(test)]

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

@@ -1,6 +1,5 @@
 use revolt_database::{
-    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    util::{permissions::DatabasePermissionQuery, reference::Reference}, voice::{sync_voice_permissions, VoiceClient}, Channel, Database, User
-    Channel, Database, User,
 };
 use revolt_models::v0;
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission, Override};
@@ -17,14 +16,15 @@ use serde::Deserialize;
 #[put("/<target>/permissions/<role_id>", data = "<data>", rank = 2)]
 pub async fn set_role_permissions(
     db: &State<Database>,
+    voice_client: &State<VoiceClient>,
     user: User,
     target: Reference,
     role_id: String,
     data: Json<v0::DataSetRolePermissions>,
 ) -> Result<Json<v0::Channel>> {
-    let mut channel = target.as_channel(db).await?;
+    let channel = target.as_channel(db).await?;
     let mut query = DatabasePermissionQuery::new(db, &user).channel(&channel);
-    let permissions = calculate_channel_permissions(&mut query).await;
+    let permissions: revolt_permissions::PermissionValue = calculate_channel_permissions(&mut query).await;
 
     permissions.throw_if_lacking_channel_permission(ChannelPermission::ManagePermissions)?;
 
@@ -39,11 +39,15 @@ pub async fn set_role_permissions(
                 .throw_permission_override(current_value, &data.permissions)
                 .await?;
 
-            channel
+            let mut new_channel = channel.clone();
+
+            new_channel
                 .set_role_permission(db, &role_id, data.permissions.clone().into())
                 .await?;
 
-            Ok(Json(channel.into()))
+            sync_voice_permissions(db, voice_client, &new_channel, Some(server), Some(&role_id)).await?;
+
+            Ok(Json(new_channel.into()))
         } else {
             Err(create_error!(NotFound))
         }

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

@@ -1,6 +1,5 @@
 use revolt_database::{
-    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    util::{permissions::DatabasePermissionQuery, reference::Reference}, voice::{sync_voice_permissions, VoiceClient}, Channel, Database, PartialChannel, User
-    Channel, Database, PartialChannel, User,
 };
 use revolt_models::v0::{self, DataDefaultChannelPermissions};
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
@@ -16,6 +15,7 @@ use rocket::{serde::json::Json, State};
 #[put("/<target>/permissions/default", data = "<data>", rank = 1)]
 pub async fn set_default_permissions(
     db: &State<Database>,
+    voice_client: &State<VoiceClient>,
     user: User,
     target: Reference,
     data: Json<v0::DataDefaultChannelPermissions>,
@@ -75,5 +75,12 @@ pub async fn set_default_permissions(
         _ => return Err(create_error!(InvalidOperation)),
     }
 
+    let server = match channel.server() {
+        Some(server_id) => Some(Reference::from_unchecked(server_id).as_server(db).await?),
+        None => None
+    };
+
+    sync_voice_permissions(db, voice_client, &channel, server.as_ref(), None).await?;
+
     Ok(Json(channel.into()))
 }

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

@@ -19,7 +19,7 @@ use validator::Validate;
 #[put("/<server>/bans/<target>", data = "<data>")]
 pub async fn ban(
     db: &State<Database>,
-    voice: &State<VoiceClient>,
+    voice_client: &State<VoiceClient>,
     user: User,
     server: Reference,
     target: Reference,
@@ -61,6 +61,7 @@ pub async fn ban(
 
         // If the member is in a voice channel while banned kick them from the voice channel
         if let Some(channel_id) = get_user_voice_channel_in_server(&user.id, &server.id).await? {
+            voice_client.remove_user(&user, &channel_id).await?;
             delete_voice_state(&channel_id, Some(&server.id), &user.id).await?
         }
     }

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

@@ -7,7 +7,7 @@ use redis_kiss::{get_connection, redis::Pipeline, AsyncCommands};
 use revolt_database::{
     events::client::EventV1,
     util::{permissions::DatabasePermissionQuery, reference::Reference},
-    voice::VoiceClient,
+    voice::{get_user_voice_channel_in_server, move_user, sync_user_voice_permissions, VoiceClient},
     Database, File, PartialMember, User,
 };
 use revolt_models::v0::{self, FieldsMember, PartialUserVoiceState};
@@ -23,8 +23,8 @@ use validator::Validate;
 #[openapi(tag = "Server Members")]
 #[patch("/<server>/members/<target>", data = "<data>")]
 pub async fn edit(
-    voice_client: &State<VoiceClient>,
     db: &State<Database>,
+    voice_client: &State<VoiceClient>,
     user: User,
     server: Reference,
     target: Reference,
@@ -190,6 +190,18 @@ pub async fn edit(
         .map(|r| r.contains(FieldsMember::CanPublish) || r.contains(FieldsMember::CanReceive))
         .unwrap_or_default();
 
+    if can_publish.is_some()
+        || can_receive.is_some()
+        || voice_channel.is_some()
+        || remove_contains_voice
+    {
+        if let Some(channel) = get_user_voice_channel_in_server(&target_user.id, &server.id).await? {
+            let channel = Reference::from_unchecked(channel).as_channel(db).await?;
+
+            sync_user_voice_permissions(db, voice_client, &user, &channel, Some(&server), None).await?;
+        };
+    };
+
     member
         .update(
             db,
@@ -200,68 +212,5 @@ pub async fn edit(
         )
         .await?;
 
-    if can_publish.is_some()
-        || can_receive.is_some()
-        || voice_channel.is_some()
-        || remove_contains_voice
-    {
-        let mut conn = get_connection().await.to_internal_error()?;
-
-        let unique_key = format!("{}-{}", &member.id.user, &member.id.server);
-
-        // if we edit the member while they are in a voice channel we need to also update the perms
-        // otherwise it wont take place until they leave and rejoin
-        if let Some(channel) = conn
-            .get::<_, Option<String>>(format!("vc-{}", &unique_key))
-            .await
-            .to_internal_error()?
-        {
-            let mut pipeline = Pipeline::new();
-            let mut new_perms = ParticipantPermission::default();
-
-            if remove_contains_voice {
-                let mut query = DatabasePermissionQuery::new(db, &target_user)
-                    .server(&server)
-                    .member(&member);
-
-                let permissions = calculate_server_permissions(&mut query).await;
-
-                if !permissions.has_channel_permission(ChannelPermission::Speak) {
-                    can_publish = Some(false)
-                }
-
-                if !permissions.has_channel_permission(ChannelPermission::Listen) {
-                    can_publish = Some(false)
-                }
-            }
-
-            if let Some(can_publish) = can_publish {
-                new_perms.can_publish = can_publish;
-                new_perms.can_publish_data = can_publish;
-            };
-
-            if let Some(can_receive) = can_receive {
-                new_perms.can_subscribe = can_receive;
-            };
-
-            if let Some(new_channel) = voice_channel {
-                pipeline.smove(
-                    format!("vc-members-{channel}"),
-                    format!("vc-members-{new_channel}"),
-                    &member.id.user,
-                );
-            };
-
-            pipeline
-                .query_async(&mut conn.into_inner())
-                .await
-                .to_internal_error()?;
-
-            voice_client
-                .update_permissions(&user, &channel, new_perms)
-                .await?;
-        };
-    };
-
     Ok(Json(member.into()))
 }

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

@@ -1,5 +1,6 @@
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
+    voice::{delete_voice_state, get_user_voice_channel_in_server, VoiceClient},
     Database, RemovalIntention, User,
 };
 use revolt_permissions::{calculate_server_permissions, ChannelPermission};
@@ -14,6 +15,7 @@ use rocket_empty::EmptyResponse;
 #[delete("/<target>/members/<member>")]
 pub async fn kick(
     db: &State<Database>,
+    voice_client: &State<VoiceClient>,
     user: User,
     target: Reference,
     member: Reference,
@@ -40,6 +42,11 @@ pub async fn kick(
         return Err(create_error!(NotElevated));
     }
 
+    if let Some(channel_id) = get_user_voice_channel_in_server(&user.id, &server.id).await? {
+        voice_client.remove_user(&user, &channel_id).await?;
+        delete_voice_state(&channel_id, Some(&server.id), &user.id).await?;
+    }
+
     member
         .remove(db, &server, RemovalIntention::Kick, false)
         .await

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

@@ -1,6 +1,5 @@
 use revolt_database::{
-    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    util::{permissions::DatabasePermissionQuery, reference::Reference}, voice::{sync_voice_permissions, VoiceClient}, Database, User
-    Database, User,
 };
 use revolt_models::v0;
 use revolt_permissions::{calculate_server_permissions, ChannelPermission, Override};
@@ -14,6 +13,7 @@ use rocket::{serde::json::Json, State};
 #[put("/<target>/permissions/<role_id>", data = "<data>", rank = 2)]
 pub async fn set_role_permission(
     db: &State<Database>,
+    voice_client: &State<VoiceClient>,
     user: User,
     target: Reference,
     role_id: String,
@@ -40,6 +40,12 @@ pub async fn set_role_permission(
             .throw_permission_override(current_value, &data.permissions)
             .await?;
 
+        for channel_id in &server.channels {
+            let channel = Reference::from_unchecked(channel_id.clone()).as_channel(db).await?;
+
+            sync_voice_permissions(db, voice_client, &channel, Some(&server), Some(&role_id)).await?;
+        };
+
         server
             .set_role_permission(db, &role_id, data.permissions.into())
             .await?;

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

@@ -1,6 +1,5 @@
 use revolt_database::{
-    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    util::{permissions::DatabasePermissionQuery, reference::Reference}, voice::{sync_voice_permissions, VoiceClient}, Database, PartialServer, Server, User
-    Database, PartialServer, Server, User,
 };
 use revolt_models::v0;
 use revolt_permissions::{
@@ -16,6 +15,7 @@ use rocket::{serde::json::Json, State};
 #[put("/<target>/permissions/default", data = "<data>", rank = 1)]
 pub async fn set_default_permissions(
     db: &State<Database>,
+    voice_client: &State<VoiceClient>,
     user: User,
     target: Reference,
     data: Json<DataPermissionsValue>,
@@ -39,6 +39,12 @@ pub async fn set_default_permissions(
         )
         .await?;
 
+    for channel_id in &server.channels {
+        let channel = Reference::from_unchecked(channel_id.clone()).as_channel(db).await?;
+
+        sync_voice_permissions(db, voice_client, &channel, Some(&server), None).await?;
+    };
+
     server
         .update(
             db,

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

@@ -1,11 +1,9 @@
-use livekit_protocol::ParticipantPermission;
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
-    voice::{get_allowed_sources, get_voice_channel_members, get_voice_state, update_voice_state, VoiceClient},
+    voice::{sync_voice_permissions, VoiceClient},
-    Channel, Database, User
+    Database, User
 };
-use revolt_models::v0::PartialUserVoiceState;
+use revolt_permissions::{calculate_server_permissions, ChannelPermission};
-use revolt_permissions::{calculate_channel_permissions, calculate_server_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};
 use rocket::State;
 use rocket_empty::EmptyResponse;
@@ -38,45 +36,7 @@ pub async fn delete(
         for channel_id in &server.channels {
             let channel = Reference::from_unchecked(channel_id.clone()).as_channel(db).await?;
 
-            if matches!(channel, Channel::VoiceChannel { .. }) {
+            sync_voice_permissions(db, voice_client, &channel, Some(&server), Some(&role_id)).await?;
-                for member_id in get_voice_channel_members(channel_id).await? {
-                    let member = Reference::from_unchecked(member_id).as_member(db, &server.id).await?;
-
-                    if member.roles.contains(&role_id) {
-                        let user = Reference::from_unchecked(member.id.user.clone()).as_user(db).await?;
-                        let voice_state = get_voice_state(channel_id, Some(&server.id), &user.id).await?.unwrap();
-
-                        let mut query = DatabasePermissionQuery::new(db, &user)
-                            .member(&member)
-                            .channel(&channel)
-                            .server(&server);
-
-                        let permissions = calculate_channel_permissions(&mut query).await;
-
-                        let mut update_event = PartialUserVoiceState {
-                            id: Some(user.id.clone()),
-                            ..Default::default()
-                        };
-
-                        let can_video = permissions.has_channel_permission(ChannelPermission::Video);
-                        let can_speak = permissions.has_channel_permission(ChannelPermission::Speak);
-                        let can_listen = permissions.has_channel_permission(ChannelPermission::Listen);
-
-                        update_event.camera = voice_state.camera.then_some(can_video);
-                        update_event.screensharing = voice_state.screensharing.then_some(can_video);
-                        update_event.is_publishing = voice_state.is_publishing.then_some(can_speak);
-
-                        update_voice_state(channel_id, Some(&server.id), &user.id, &update_event).await?;
-
-                        voice_client.update_permissions(&user, channel_id, ParticipantPermission {
-                            can_subscribe: can_listen,
-                            can_publish: can_speak,
-                            can_publish_data: can_speak,
-                            ..Default::default()
-                        }).await?;
-                    }
-                }
-            }
         };
 
         role.delete(db, &server.id, &role_id)

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

@@ -1,14 +1,12 @@
-use livekit_protocol::ParticipantPermission;
 use revolt_database::{
     util::{permissions::DatabasePermissionQuery, reference::Reference},
-    voice::{get_allowed_sources, get_voice_channel_members, get_voice_state, update_voice_state, update_voice_state_tracks, VoiceClient},
+    voice::{sync_voice_permissions, VoiceClient},
-    Channel, Database, PartialRole, User
+    Database, PartialRole, User
 };
-use revolt_models::v0::{self, PartialUserVoiceState};
+use revolt_models::v0;
-use revolt_permissions::{calculate_channel_permissions, calculate_server_permissions, ChannelPermission, PermissionQuery};
+use revolt_permissions::{calculate_server_permissions, ChannelPermission};
 use revolt_result::{create_error, Result};
 use rocket::{serde::json::Json, State};
-use serde::{Deserialize, Serialize};
 use validator::Validate;
 
 /// # Edit Role
@@ -18,12 +16,11 @@ use validator::Validate;
 #[patch("/<target>/roles/<role_id>", data = "<data>")]
 pub async fn edit(
     db: &State<Database>,
-    voice: &State<VoiceClient>,
+    voice_client: &State<VoiceClient>,
     user: User,
     target: Reference,
     role_id: String,
     data: Json<v0::DataEditRole>,
-    voice_client: &State<VoiceClient>
 ) -> Result<Json<v0::Role>> {
     let data = data.into_inner();
     data.validate().map_err(|error| {
@@ -83,45 +80,7 @@ pub async fn edit(
         for channel_id in &server.channels {
             let channel = Reference::from_unchecked(channel_id.clone()).as_channel(db).await?;
 
-            if matches!(channel, Channel::VoiceChannel { .. }) {
+            sync_voice_permissions(db, voice_client, &channel, Some(&server), Some(&role_id)).await?;
-                for member_id in get_voice_channel_members(channel_id).await? {
-                    let member = Reference::from_unchecked(member_id).as_member(db, &server.id).await?;
-
-                    if member.roles.contains(&role_id) {
-                        let user = Reference::from_unchecked(member.id.user.clone()).as_user(db).await?;
-                        let voice_state = get_voice_state(channel_id, Some(&server.id), &user.id).await?.unwrap();
-
-                        let mut query = DatabasePermissionQuery::new(db, &user)
-                            .member(&member)
-                            .channel(&channel)
-                            .server(&server);
-
-                        let permissions = calculate_channel_permissions(&mut query).await;
-
-                        let mut update_event = PartialUserVoiceState {
-                            id: Some(user.id.clone()),
-                            ..Default::default()
-                        };
-
-                        let can_video = permissions.has_channel_permission(ChannelPermission::Video);
-                        let can_speak = permissions.has_channel_permission(ChannelPermission::Speak);
-                        let can_listen = permissions.has_channel_permission(ChannelPermission::Listen);
-
-                        update_event.camera = voice_state.camera.then_some(can_video);
-                        update_event.screensharing = voice_state.screensharing.then_some(can_video);
-                        update_event.is_publishing = voice_state.is_publishing.then_some(can_speak);
-
-                        update_voice_state(channel_id, Some(&server.id), &user.id, &update_event).await?;
-
-                        voice_client.update_permissions(&user, channel_id, ParticipantPermission {
-                            can_subscribe: can_listen,
-                            can_publish: can_speak,
-                            can_publish_data: can_speak,
-                            ..Default::default()
-                        }).await?;
-                    }
-                }
-            }
         };
 
         Ok(Json(role.into()))

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

@@ -1,4 +1,8 @@
-use revolt_database::{util::reference::Reference, Database, RemovalIntention, User};
+use revolt_database::{
+    util::reference::Reference,
+    voice::{delete_voice_state, get_user_voice_channel_in_server, VoiceClient},
+    Database, RemovalIntention, User,
+};
 use revolt_models::v0;
 use revolt_result::Result;
 use rocket::State;
@@ -12,6 +16,7 @@ use rocket_empty::EmptyResponse;
 #[delete("/<target>?<options..>")]
 pub async fn delete(
     db: &State<Database>,
+    voice_client: &State<VoiceClient>,
     user: User,
     target: Reference,
     options: v0::OptionsServerDelete,
@@ -20,8 +25,20 @@ pub async fn delete(
     let member = db.fetch_member(&target.id, &user.id).await?;
 
     if server.owner == user.id {
+        for channel_id in &server.channels {
+            voice_client.remove_user(&user, channel_id).await?;
+            delete_voice_state(channel_id, Some(&server.id), &user.id).await?;
+        }
+
         server.delete(db).await
     } else {
+        if let Some(channel_id) = get_user_voice_channel_in_server(&user.id, &server.id).await? {
+            if server.channels.iter().any(|c| c == &channel_id) {
+                voice_client.remove_user(&user, &channel_id).await?;
+                delete_voice_state(&channel_id, Some(&server.id), &user.id).await?;
+            }
+        };
+
         member
             .remove(
                 db,