automatically grant user roles on join

Author: zkxs

.sqlx/query-47e50e24066c6d0ed4911b921f37766e6cb2508de9a0b9b8e91b5ded8e39e4f3.json

@@ -4,8 +4,8 @@
 
 ### I've left and rejoined a server and lost my roles. Can I get them back?
 
-Yes, just re-register your license key again. As long as you're using the same Discord account that originally registered
-the license, Jinx will happily grant the roles again.
+Jinx should automatically restore your roles if you rejoin a server, but if for some reason this fails you can
+manually re-register your license key again using the register button.
 
 ### I've lost my Discord account and had to make a new one. Can I move my Jinxxy license?
 

docs/faq.md

@@ -15,7 +15,7 @@ use regex::Regex;
 use serenity::{
     Colour, Context, CreateEmbed, CreateInputText, CreateInteractionResponse, CreateInteractionResponseMessage,
     CreateLabel, CreateMessage, CreateModal, CreateModalComponent, CreateTextDisplay, EditInteractionResponse, Error,
-    Event, EventHandler, FullEvent, GenericChannelId, GuildId, InputTextStyle, Interaction, LabelComponent,
+    Event, EventHandler, FullEvent, GenericChannelId, GuildId, InputTextStyle, Interaction, LabelComponent, Member,
     ModalComponent, ModalInteraction, RatelimitInfo,
 };
 use std::borrow::Cow;
@@ -240,6 +240,24 @@ impl EventHandler for Data {
                     command_interaction.user.id.get()
                 );
             }
+            FullEvent::GuildMemberAddition { new_member, .. } => {
+                // If a banned user joins a guild, do nothing
+                match self.db.get_user_ban(new_member.user.id).await {
+                    Ok(banned) => {
+                        if banned {
+                            info!("Ignored join event for banned user {}", new_member.user.id.get());
+                            return;
+                        }
+                    }
+                    Err(e) => {
+                        warn!("Could not check user ban: {e:?}");
+                    }
+                }
+
+                if let Err(e) = grant_member_roles(self, context, new_member).await {
+                    error!("Error granting roles on join: {e:?}");
+                }
+            }
             FullEvent::GuildRoleDelete {
                 guild_id,
                 removed_role_id,
@@ -519,6 +537,67 @@ impl EventHandler for Data {
     }
 }
 
+/// Grant any missing roles to a member
+async fn grant_member_roles(data: &Data, context: &Context, new_member: &Member) -> Result<(), JinxError> {
+    let roles = data
+        .db
+        .get_roles_for_user(new_member.guild_id, new_member.user.id)
+        .await?;
+    let mut granted_roles = Vec::new();
+    let mut errored_roles = Vec::new();
+    for role in roles {
+        if !new_member.roles.contains(&role) {
+            let result = new_member.add_role(&context.http, role, Some("new user join")).await;
+            if let Err(e) = result {
+                warn!("Error adding role to new member. Skipping: {:?}", e);
+                errored_roles.push(role);
+            } else {
+                granted_roles.push(role);
+            }
+        }
+    }
+
+    if !granted_roles.is_empty() || !errored_roles.is_empty() {
+        debug!(
+            "Granted missing roles to {} in {}",
+            new_member.user.id.get(),
+            new_member.guild_id.get()
+        );
+
+        // also send a notification to the guild owner bot log if it's set up for this guild
+        if let Some(log_channel) = data.db.get_log_channel(new_member.guild_id).await? {
+            let mut owner_message = format!(
+                "<@{}> has rejoined the server and been granted the following roles:",
+                new_member.user.id
+            );
+            for role in granted_roles {
+                owner_message.push_str(format!("\n- <@&{}>", role.get()).as_str());
+            }
+            if !errored_roles.is_empty() {
+                owner_message.push_str("\nCould not grant the following roles, likely due to missing permissions:");
+                for role in errored_roles {
+                    owner_message.push_str(format!("\n- <@&{}>", role.get()).as_str());
+                }
+            }
+
+            let embed = CreateEmbed::default()
+                .title("User Rejoin")
+                .color(Colour::GOLD)
+                .description(owner_message);
+            let bot_log_message = CreateMessage::default().embed(embed);
+            send_bot_log_message(
+                data.db.clone(),
+                context,
+                new_member.guild_id,
+                log_channel,
+                bot_log_message,
+            );
+        }
+    }
+
+    Ok(())
+}
+
 async fn handle_license_registration(
     data: &Data,
     context: &Context,

docs/images/user_rejoin.png

@@ -139,7 +139,8 @@ impl BotBuilder {
         let discord_token = Token::try_from(discord_token)?;
         let intents = GatewayIntents::GUILDS
             .union(GatewayIntents::GUILD_MESSAGES)
-            .union(GatewayIntents::DIRECT_MESSAGES);
+            .union(GatewayIntents::DIRECT_MESSAGES)
+            .union(GatewayIntents::GUILD_MEMBERS);
         let commands = GLOBAL_COMMANDS
             .iter()
             .chain(CREATOR_COMMANDS.iter())

src/bot/event_handler.rs

@@ -1057,6 +1057,7 @@ impl JinxDb {
         Ok(result)
     }
 
+    /// get all users in a guild that should have the given role
     pub async fn get_users_for_role(&self, guild: GuildId, role: RoleId) -> JinxResult<Vec<UserId>> {
         let guild_id = guild.get() as i64;
         let role_id = role.get() as i64;
@@ -1073,6 +1074,23 @@ impl JinxDb {
         Ok(result)
     }
 
+    /// get all roles in a guild the given user should have
+    pub async fn get_roles_for_user(&self, guild: GuildId, user: UserId) -> JinxResult<Vec<RoleId>> {
+        let guild_id = guild.get() as i64;
+        let user_id = user.get() as i64;
+        let result = sqlx::query!(
+            r#"SELECT DISTINCT blanket_role_id as "role_id!" FROM license_activation INNER JOIN jinxxy_user_guild USING (jinxxy_user_id) INNER JOIN guild USING (guild_id) WHERE guild_id = ?1 AND activator_user_id = ?2 AND blanket_role_id IS NOT NULL
+               UNION SELECT DISTINCT role_id FROM license_activation INNER JOIN jinxxy_user_guild USING (jinxxy_user_id) INNER JOIN product_role USING (guild_id, jinxxy_user_id, product_id) WHERE guild_id = ?1 AND activator_user_id = ?2
+               UNION SELECT DISTINCT role_id FROM license_activation INNER JOIN jinxxy_user_guild USING (jinxxy_user_id) INNER JOIN product_version_role USING (guild_id, jinxxy_user_id, product_id, version_id) WHERE guild_id = ?1 AND activator_user_id = ?2"#,
+            guild_id,
+            user_id,
+        )
+            .map(|row| RoleId::new(row.role_id as u64))
+            .fetch_all(&self.read_pool)
+            .await?;
+        Ok(result)
+    }
+
     /// get distinct roles from all links
     pub async fn get_linked_roles(&self, guild: GuildId) -> JinxResult<Vec<RoleId>> {
         let guild_id = guild.get() as i64;