refactor: fix clippy warnings

Author: ap-1

src/bot/commands/unverify.rs

@@ -58,16 +58,14 @@ pub async fn handle(
     };
 
     // If targeting another user, require administrator permissions
-    if target_user.id != user.id {
-        if !is_admin(ctx, &command.member, guild_id, user.id).await? {
-            let response = CreateInteractionResponse::Message(
-                CreateInteractionResponseMessage::new()
-                    .content("You need administrator permissions to unverify other users.")
-                    .ephemeral(true),
-            );
-            command.create_response(&ctx.http, response).await?;
-            return Ok(());
-        }
+    if target_user.id != user.id && !is_admin(ctx, &command.member, guild_id, user.id).await? {
+        let response = CreateInteractionResponse::Message(
+            CreateInteractionResponseMessage::new()
+                .content("You need administrator permissions to unverify other users.")
+                .ephemeral(true),
+        );
+        command.create_response(&ctx.http, response).await?;
+        return Ok(());
     }
 
     // Look up Keycloak user ID from Redis
@@ -108,12 +106,11 @@ pub async fn handle(
     // Remove verified role
     let member = guild_id.member(&ctx.http, target_user.id).await?;
 
-    if let Ok(role_config) = load_guild_role_config(&ctx.http, &mut conn, guild_id).await {
-        if let Ok(verified_role) = role_config.get_verified_role() {
-            if member.roles.contains(&verified_role) {
-                member.remove_role(&ctx.http, verified_role, None).await?;
-            }
-        }
+    if let Ok(role_config) = load_guild_role_config(&ctx.http, &mut conn, guild_id).await
+        && let Ok(verified_role) = role_config.get_verified_role()
+        && member.roles.contains(&verified_role)
+    {
+        member.remove_role(&ctx.http, verified_role, None).await?;
     }
 
     let response = CreateInteractionResponse::Message(

src/bot/commands/verify.rs

@@ -131,29 +131,23 @@ pub async fn complete_verification(
     // Assign additional roles based on mode and user attributes
     if let Some(attrs) = keycloak_user.attributes.as_ref() {
         // Try to assign level-based role
-        if role_config.should_assign_level_roles() {
-            if let Some(level_values) = attrs.get("level") {
-                if let Some(level) = level_values.first() {
-                    if let Some(level_role) = role_config.get_level_role(level) {
-                        if let Err(e) = member.add_role(http, level_role, None).await {
-                            tracing::warn!("Failed to assign level role {}: {}", level, e);
-                        }
-                    }
-                }
-            }
+        if role_config.should_assign_level_roles()
+            && let Some(level_values) = attrs.get("level")
+            && let Some(level) = level_values.first()
+            && let Some(level_role) = role_config.get_level_role(level)
+            && let Err(e) = member.add_role(http, level_role, None).await
+        {
+            tracing::warn!("Failed to assign level role {}: {}", level, e);
         }
 
         // Try to assign class-based role
-        if role_config.should_assign_class_roles() {
-            if let Some(class_values) = attrs.get("class") {
-                if let Some(class) = class_values.first() {
-                    if let Some(class_role) = role_config.get_class_role(class) {
-                        if let Err(e) = member.add_role(http, class_role, None).await {
-                            tracing::warn!("Failed to assign class role {}: {}", class, e);
-                        }
-                    }
-                }
-            }
+        if role_config.should_assign_class_roles()
+            && let Some(class_values) = attrs.get("class")
+            && let Some(class) = class_values.first()
+            && let Some(class_role) = role_config.get_class_role(class)
+            && let Err(e) = member.add_role(http, class_role, None).await
+        {
+            tracing::warn!("Failed to assign class role {}: {}", class, e);
         }
     }
 

src/bot/role_config.rs

@@ -2,6 +2,7 @@ use crate::bot::Error;
 use redis::AsyncCommands;
 use serenity::all::{GuildId, Http, RoleId};
 use std::collections::HashMap;
+use std::str::FromStr;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RoleMode {
@@ -11,16 +12,20 @@ pub enum RoleMode {
     Custom,
 }
 
-impl RoleMode {
-    pub fn from_str(s: &str) -> Self {
-        match s {
+impl FromStr for RoleMode {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
             "levels" => Self::Levels,
             "classes" => Self::Classes,
             "custom" => Self::Custom,
             _ => Self::None,
-        }
+        })
     }
+}
 
+impl RoleMode {
     pub fn as_str(&self) -> &str {
         match self {
             Self::None => "none",
@@ -57,21 +62,24 @@ impl GuildRoleConfig {
         // Get the role mode
         let role_mode_key = format!("guild:{}:role_mode", guild_id);
         let role_mode: Option<String> = redis.get(&role_mode_key).await?;
-        let mode = RoleMode::from_str(&role_mode.unwrap_or_else(|| "none".to_string()));
+        let mode = role_mode
+            .unwrap_or_else(|| "none".to_string())
+            .parse()
+            .unwrap_or(RoleMode::None);
 
         // Get level roles
         let mut level_roles = HashMap::new();
         for level in &["Undergrad", "Graduate"] {
             let key = format!("guild:{}:role:level:{}", guild_id, level);
-            if let Ok(Some(role_id_str)) = redis.get::<_, Option<String>>(&key).await {
-                if let Ok(role_id_u64) = role_id_str.parse::<u64>() {
-                    // Verify the role still exists
-                    let role_id = RoleId::new(role_id_u64);
-                    let roles = guild_id.roles(http).await?;
-
-                    if roles.contains_key(&role_id) {
-                        level_roles.insert(level.to_string(), role_id);
-                    }
+            if let Ok(Some(role_id_str)) = redis.get::<_, Option<String>>(&key).await
+                && let Ok(role_id_u64) = role_id_str.parse::<u64>()
+            {
+                // Verify the role still exists
+                let role_id = RoleId::new(role_id_u64);
+                let roles = guild_id.roles(http).await?;
+
+                if roles.contains_key(&role_id) {
+                    level_roles.insert(level.to_string(), role_id);
                 }
             }
         }
@@ -88,15 +96,15 @@ impl GuildRoleConfig {
             "Doctoral",
         ] {
             let key = format!("guild:{}:role:class:{}", guild_id, class);
-            if let Ok(Some(role_id_str)) = redis.get::<_, Option<String>>(&key).await {
-                if let Ok(role_id_u64) = role_id_str.parse::<u64>() {
-                    // Verify the role still exists
-                    let role_id = RoleId::new(role_id_u64);
-                    let roles = guild_id.roles(http).await?;
-
-                    if roles.contains_key(&role_id) {
-                        class_roles.insert(class.to_string(), role_id);
-                    }
+            if let Ok(Some(role_id_str)) = redis.get::<_, Option<String>>(&key).await
+                && let Ok(role_id_u64) = role_id_str.parse::<u64>()
+            {
+                // Verify the role still exists
+                let role_id = RoleId::new(role_id_u64);
+                let roles = guild_id.roles(http).await?;
+
+                if roles.contains_key(&role_id) {
+                    class_roles.insert(class.to_string(), role_id);
                 }
             }
         }