refactor: minor formatting changes

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

@@ -254,12 +254,12 @@ impl Server {
         }
     }
 
-    /// reorders the server's roles rankings
+    /// Reorders the server's roles rankings
-    pub async fn update_role_rankings(&mut self, db: &Database, new_order: Vec<String>) -> Result<()> {
+    pub async fn set_role_ordering(&mut self, db: &Database, new_order: Vec<String>) -> Result<()> {
-        // new_order must always contain every role
+        // New order must always contain every role
         debug_assert_eq!(self.roles.len(), new_order.len());
 
-        // set the role's ranks to the positions in the vec
+        // Set the role's ranks to the positions in the vec
         for (rank, id) in new_order.iter().enumerate() {
             self.roles.get_mut(id).unwrap().rank = rank as i64;
         }
@@ -270,13 +270,14 @@ impl Server {
                 roles: Some(self.roles.clone()),
                 ..Default::default()
             },
-            Vec::new()
+            Vec::new(),
-        ).await?;
+        )
+        .await?;
 
-        // publish bulk update event
+        // Publish bulk update event
-        EventV1::ServerRoleRanksUpdate {
+        EventV1::ServerRoleRanksUpdate { ranks: new_order }
-            ranks: new_order
+            .p(self.id.clone())
-        }.p(self.id.clone()).await;
+            .await;
 
         Ok(())
     }

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

@@ -267,8 +267,7 @@ auto_derived!(
         pub hoist: Option<bool>,
         /// Ranking position
         ///
-        /// **Deprecated** - use the edit server role positions route.
+        /// **Removed** - no effect, use the edit server role positions route
-        /// Smaller values take priority.
         pub rank: Option<i64>,
         /// Fields to remove from role object
         #[cfg_attr(feature = "validator", validate(length(min = 1)))]

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

@@ -46,7 +46,6 @@ pub async fn edit(
             colour,
             hoist,
             remove,
-            // rank is deprecated
             ..
         } = data;
 

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

@@ -1,8 +1,11 @@
-use revolt_database::{events::client::EventV1, util::{permissions::DatabasePermissionQuery, reference::Reference}, Database, PartialRole, PartialServer, User};
+use revolt_database::{
-use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+    util::{permissions::DatabasePermissionQuery, reference::Reference},
-use rocket::{serde::json::Json, State};
+    Database, User,
-use revolt_result::{create_error, Result};
+};
 use revolt_models::v0;
+use revolt_permissions::{calculate_server_permissions, ChannelPermission};
+use revolt_result::{create_error, Result};
+use rocket::{serde::json::Json, State};
 
 /// # Edits server roles ranks
 ///
@@ -26,27 +29,41 @@ pub async fn edit_role_ranks(
     let existing_order = server.roles.keys().cloned().collect::<Vec<_>>();
     let new_order = data.ranks.clone().into_iter().collect::<Vec<_>>();
 
-    // verify all roles are in the new ordering
+    // Verify all roles are in the new ordering
-    if data.ranks.len() != server.roles.len() && server.roles.iter().all(|(id, _)| data.ranks.contains(id)) {
+    if data.ranks.len() != server.roles.len()
-        return Err(create_error!(InvalidOperation))
+        && server.roles.iter().all(|(id, _)| data.ranks.contains(id))
+    {
+        return Err(create_error!(InvalidOperation));
     }
 
-    // dont have to check what the user cant modify if they are the server owner
+    // Don't have to check what the user cant modify if they are the server owner
     if server.owner != user.id {
         let member_top_rank = query.get_member_rank();
 
-        // find all roles above the member which we should not be able to reorder then
+        if server
-        // check if any roles which we cant reorder have tried to been reordered
+            .roles
-        if server.roles
             .iter()
-            .filter(|(_, role)| if let Some(top_rank) = member_top_rank { role.rank <= top_rank } else { true })
+            // Find all roles above the member which we should not be able to reorder
-            .any(|(id, _)| existing_order.iter().position(|existing_id| id == existing_id) != new_order.iter().position(|new_id| id == new_id))
+            .filter(|(_, role)| {
+                if let Some(top_rank) = member_top_rank {
+                    role.rank <= top_rank
+                } else {
+                    true
+                }
+            })
+            // Check if user is trying to reorder roles they can't reorder (as found previously)
+            .any(|(id, _)| {
+                existing_order
+                    .iter()
+                    .position(|existing_id| id == existing_id)
+                    != new_order.iter().position(|new_id| id == new_id)
+            })
         {
-            return Err(create_error!(NotElevated))
+            return Err(create_error!(NotElevated));
         }
     }
 
-    server.update_role_rankings(db, new_order).await?;
+    server.set_role_ordering(db, new_order).await?;
 
     Ok(Json(server.into()))
 }