feat: being moved between voice channels

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

@@ -258,11 +258,16 @@ pub enum EventV1 {
         user: String,
         from: String,
         to: String,
+        state: UserVoiceState
     },
     UserVoiceStateUpdate {
         id: String,
         channel_id: String,
         data: PartialUserVoiceState,
+    },
+    UserMoveVoiceChannel {
+        node: String,
+        token: String
     }
 }
 

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

@@ -29,7 +29,7 @@ pub async fn raise_if_in_voice(user: &User, target: &str) -> Result<()> {
         .to_internal_error()?
         > 0
     {
-        Err(create_error!(AlreadyInVoiceChannel))
+        Err(create_error!(NotConnected))
     } else {
         Ok(())
     }
@@ -45,7 +45,7 @@ pub async fn set_channel_node(channel: &str, node: &str) -> Result<()> {
     Ok(())
 }
 
-pub async fn get_channel_node(channel: &str) -> Result<String> {
+pub async fn get_channel_node(channel: &str) -> Result<Option<String>> {
     get_connection()
         .await?
         .get(format!("node:{channel}"))
@@ -61,6 +61,22 @@ pub async fn get_user_voice_channels(user_id: &str) -> Result<Vec<String>> {
         .to_internal_error()
 }
 
+pub async fn set_user_moved_from_voice(old_channel: &str, new_channel: &str, user_id: &str) -> Result<()> {
+    get_connection()
+        .await?
+        .set_ex(format!("moved_to:{user_id}:{new_channel}"), old_channel, 10)
+        .await
+        .to_internal_error()
+}
+
+pub async fn get_user_moved_from_voice(channel_id: &str, user_id: &str) -> Result<Option<String>> {
+    get_connection()
+        .await?
+        .get(format!("moved_to:{user_id}:{channel_id}"))
+        .await
+        .to_internal_error()
+}
+
 pub async fn is_in_voice_channel(user_id: &str, channel_id: &str) -> Result<bool> {
     get_connection()
         .await?
@@ -275,7 +291,7 @@ pub async fn get_channel_voice_state(channel: &Channel) -> Result<Option<v0::Cha
 
     if let Some(members) = members {
         let mut participants = Vec::with_capacity(members.len());
-        let node = get_channel_node(channel.id()).await?;
+        let node = get_channel_node(channel.id()).await?.unwrap();
 
         for user_id in members {
             if let Some(voice_state) = get_voice_state(channel.id(), server, &user_id).await? {
@@ -312,7 +328,7 @@ pub async fn move_user(user: &str, from: &str, to: &str) -> Result<()> {
 }
 
 pub async fn sync_voice_permissions(db: &Database, voice_client: &VoiceClient, channel: &Channel, server: Option<&Server>, role_id: Option<&str>) -> Result<()> {
-    let node = get_channel_node(channel.id()).await?;
+    let node = get_channel_node(channel.id()).await?.unwrap();
 
     for user_id in get_voice_channel_members(channel.id()).await?.iter().flatten() {
         let user = Reference::from_unchecked(user_id.clone()).as_user(db).await?;

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

@@ -97,7 +97,7 @@ impl VoiceClient {
                 channel.id(),
                 CreateRoomOptions {
                     max_participants: voice.max_users.unwrap_or(u32::MAX),
-                    empty_timeout: 5 * 60, // 5 minutes
+                    empty_timeout: 5 * 60, // 5 minutes,
                     ..Default::default()
                 },
             )

crates/core/result/src/axum.rs

@@ -75,7 +75,7 @@ impl IntoResponse for Error {
             ErrorType::NoEffect => StatusCode::OK,
             ErrorType::FailedValidation { .. } => StatusCode::BAD_REQUEST,
             ErrorType::LiveKitUnavailable => StatusCode::BAD_REQUEST,
-            ErrorType::AlreadyInVoiceChannel => StatusCode::BAD_REQUEST,
+            ErrorType::NotConnected => StatusCode::BAD_REQUEST,
             ErrorType::NotAVoiceChannel => StatusCode::BAD_REQUEST,
             ErrorType::AlreadyConnected => StatusCode::BAD_REQUEST,
             ErrorType::UnknownNode => StatusCode::BAD_REQUEST,

crates/core/result/src/lib.rs

@@ -158,9 +158,9 @@ pub enum ErrorType {
 
     // ? Voice errors
     LiveKitUnavailable,
-    AlreadyInVoiceChannel,
     NotAVoiceChannel,
     AlreadyConnected,
+    NotConnected,
     UnknownNode,
     // ? Micro-service errors
     ProxyError,

crates/core/result/src/rocket.rs

@@ -79,9 +79,9 @@ impl<'r> Responder<'r, 'static> for Error {
             ErrorType::NoEffect => Status::Ok,
             ErrorType::FailedValidation { .. } => Status::BadRequest,
             ErrorType::LiveKitUnavailable => Status::BadRequest,
-            ErrorType::AlreadyInVoiceChannel => Status::BadRequest,
             ErrorType::NotAVoiceChannel => Status::BadRequest,
             ErrorType::AlreadyConnected => Status::BadRequest,
+            ErrorType::NotConnected => Status::BadRequest,
             ErrorType::UnknownNode => Status::BadRequest,
             ErrorType::ProxyError => Status::BadRequest,
             ErrorType::FileTooSmall => Status::UnprocessableEntity,

crates/daemons/voice-ingress/src/main.rs

@@ -4,8 +4,7 @@ use std::env;
 use livekit_protocol::TrackType;
 use livekit_api::{access_token::TokenVerifier, webhooks::WebhookReceiver};
 use revolt_database::{
-    events::client::EventV1, util::reference::Reference, Database, DatabaseInfo,
+    events::client::EventV1, util::reference::Reference, voice::{create_voice_state, delete_voice_state, get_user_moved_from_voice, update_voice_state_tracks, VoiceClient}, Database, DatabaseInfo
-    voice::{create_voice_state, delete_voice_state, update_voice_state_tracks, VoiceClient}
 };
 use rocket::{build, http::Status, post, request::{FromRequest, Outcome}, routes, Config, Request, State};
 use rocket_empty::EmptyResponse;
@@ -83,12 +82,23 @@ async fn ingress(db: &State<Database>, node: &str, voice_client: &State<VoiceCli
 
             let voice_state = create_voice_state(channel_id, channel.server(), user_id).await?;
 
-            EventV1::VoiceChannelJoin {
+            if let Some(moved_from) = get_user_moved_from_voice(channel_id, user_id).await? {
-                id: channel_id.clone(),
+                EventV1::VoiceChannelMove {
-                state: voice_state,
+                    user: user_id.clone(),
-            }
+                    from: moved_from,
-            .p(channel_id.clone())
+                    to: channel_id.clone(),
-            .await
+                    state: voice_state
+                }
+                .p(channel_id.clone())
+                .await;
+            } else {
+                EventV1::VoiceChannelJoin {
+                    id: channel_id.clone(),
+                    state: voice_state,
+                }
+                .p(channel_id.clone())
+                .await;
+            };
         }
         "participant_left" => {
             let channel_id = channel_id.to_internal_error()?;

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

@@ -54,7 +54,7 @@ pub async fn delete(
     };
 
     if let Some(users) = get_voice_channel_members(channel.id()).await? {
-        let node = get_channel_node(channel.id()).await?;
+        let node = get_channel_node(channel.id()).await?.unwrap();
 
         for user in users {
             voice_client.remove_user(&node, &user, channel.id()).await?;

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

@@ -48,8 +48,8 @@ pub async fn remove_member(
     };
 
     if is_in_voice_channel(&user.id, channel.id()).await? {
-        let node = get_channel_node(channel.id()).await?;
+        let node = get_channel_node(channel.id()).await?.unwrap();
-        
+
         voice_client.remove_user(&node, &user.id, channel.id()).await?;
         delete_voice_state(channel.id(), None, &user.id).await?;
     };

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

@@ -61,7 +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? {
-            let node = get_channel_node(&channel_id).await?;
+            let node = get_channel_node(&channel_id).await?.unwrap();
             voice_client.remove_user(&node, &user.id, &channel_id).await?;
             delete_voice_state(&channel_id, Some(&server.id), &user.id).await?
         }

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

@@ -6,13 +6,13 @@ use livekit_protocol::ParticipantPermission;
 use redis_kiss::{get_connection, redis::Pipeline, AsyncCommands};
 use revolt_database::{
     events::client::EventV1,
-    util::{permissions::DatabasePermissionQuery, reference::Reference},
+    util::{permissions::{perms, DatabasePermissionQuery}, reference::Reference},
-    voice::{get_channel_node, get_user_voice_channel_in_server, move_user, sync_user_voice_permissions, VoiceClient},
+    voice::{get_channel_node, get_user_voice_channel_in_server, move_user, set_channel_node, set_user_moved_from_voice, sync_user_voice_permissions, VoiceClient},
     Database, File, PartialMember, User,
 };
 use revolt_models::v0::{self, FieldsMember, PartialUserVoiceState};
 
-use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+use revolt_permissions::{calculate_channel_permissions, calculate_server_permissions, ChannelPermission};
 use revolt_result::{create_error, Result, ToRevoltError};
 use rocket::{form::validate::Contains, serde::json::Json, State};
 use validator::Validate;
@@ -103,7 +103,7 @@ pub async fn edit(
         permissions.throw_if_lacking_channel_permission(ChannelPermission::DeafenMembers)?;
     }
 
-    if let Some(new_channel) = &data.voice_channel {
+    let new_voice_channel = if let Some(new_channel) = &data.voice_channel {
         permissions.throw_if_lacking_channel_permission(ChannelPermission::MoveMembers)?;
 
         // ensure the channel we are moving them to is in the server and is a voice channel
@@ -113,14 +113,18 @@ pub async fn edit(
             .await
             .map_err(|_| create_error!(UnknownChannel))?;
 
-        if !channel.server().is_some_and(|v| v == member.id.server) {
+        if channel.server().is_none_or(|v| v != member.id.server) {
             Err(create_error!(UnknownChannel))?
         }
 
-        if channel.voice().is_none() {
+        if get_user_voice_channel_in_server(&target_user.id, &server.id).await?.is_none() {
-            Err(create_error!(NotAVoiceChannel))?
+            Err(create_error!(NotConnected))?
-        }
+        };
-    }
+
+        Some(channel)
+    } else {
+        None
+    };
 
     // Resolve our ranking
     let our_ranking = query.get_member_rank().unwrap_or(i64::MIN);
@@ -159,7 +163,7 @@ pub async fn edit(
         remove,
         can_publish,
         can_receive,
-        voice_channel,
+        voice_channel: _,
     } = data;
 
     let mut partial = PartialMember {
@@ -185,27 +189,11 @@ pub async fn edit(
         partial.avatar = Some(File::use_user_avatar(db, &avatar, &user.id, &user.id).await?);
     }
 
-    // TODO: impelement moving users
-
     let remove_contains_voice = remove
         .as_ref()
         .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 node = get_channel_node(&channel).await?;
-            let channel = Reference::from_unchecked(channel).as_channel(db).await?;
-
-
-            sync_user_voice_permissions(db, voice_client, &node, &user, &channel, Some(&server), None).await?;
-        };
-    };
-
     member
         .update(
             db,
@@ -216,5 +204,43 @@ pub async fn edit(
         )
         .await?;
 
+    if let Some(new_voice_channel) = new_voice_channel {
+        if let Some(channel) = get_user_voice_channel_in_server(&target_user.id, &server.id).await? {
+            let old_node = get_channel_node(&channel).await?.unwrap();
+
+            let new_node = match get_channel_node(new_voice_channel.id()).await? {
+                Some(node) => node,
+                None => {
+                    set_channel_node(new_voice_channel.id(), &old_node).await?;
+                    old_node.clone()
+                }
+            };
+
+            set_user_moved_from_voice(&channel, new_voice_channel.id(), &target_user.id).await?;
+
+            let mut query = perms(db, &target_user).channel(&new_voice_channel);
+            let permissions = calculate_channel_permissions(&mut query).await;
+
+            voice_client.create_room(&new_node, &new_voice_channel).await?;
+            let token = voice_client.create_token(&new_node, &target_user, permissions, &new_voice_channel)?;
+
+            voice_client.remove_user(&old_node, &target_user.id, &channel).await?;
+
+            EventV1::UserMoveVoiceChannel {
+                node: new_node,
+                token
+            }
+            .p_user(target_user.id.clone(), db)
+            .await;
+        };
+    } else if can_publish.is_some() || can_receive.is_some() || remove_contains_voice {
+        if let Some(channel) = get_user_voice_channel_in_server(&target_user.id, &server.id).await? {
+            let node = get_channel_node(&channel).await?.unwrap();
+            let channel = Reference::from_unchecked(channel).as_channel(db).await?;
+
+            sync_user_voice_permissions(db, voice_client, &node, &user, &channel, Some(&server), None).await?;
+        };
+    };
+
     Ok(Json(member.into()))
 }

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

@@ -43,7 +43,7 @@ pub async fn kick(
     }
 
     if let Some(channel_id) = get_user_voice_channel_in_server(&user.id, &server.id).await? {
-        let node = get_channel_node(&channel_id).await?;
+        let node = get_channel_node(&channel_id).await?.unwrap();
 
         voice_client.remove_user(&node, &user.id, &channel_id).await?;
         delete_voice_state(&channel_id, Some(&server.id), &user.id).await?;

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

@@ -27,7 +27,7 @@ pub async fn delete(
     if server.owner == user.id {
         for channel_id in &server.channels {
             if let Some(users) = get_voice_channel_members(channel_id).await? {
-                let node = get_channel_node(channel_id).await?;
+                let node = get_channel_node(channel_id).await?.unwrap();
 
                 for user in users {
                     voice_client.remove_user(&node, &user, channel_id).await?;
@@ -40,7 +40,7 @@ pub async fn delete(
     } 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) {
-                let node = get_channel_node(&channel_id).await?;
+                let node = get_channel_node(&channel_id).await?.unwrap();
                 voice_client.remove_user(&node, &user.id, &channel_id).await?;
                 delete_voice_state(&channel_id, Some(&server.id), &user.id).await?;
             }