feat: avoid recently selected members

Author: AnandajithS

src/commands/random.rs

@@ -3,29 +3,84 @@ use crate::{
     Context, Error,
 };
 use rand::seq::IteratorRandom;
-use serenity::all::{Mentionable as _, RoleId};
+use serenity::all::{Mentionable as _, RoleId, UserId};
+use std::collections::HashSet;
 
 #[poise::command(slash_command)]
 pub async fn random(ctx: Context<'_>) -> Result<(), Error> {
     let guild = ctx.guild_id().ok_or("No guild id")?;
     let members = guild.members(ctx.http(), None, None).await?;
-
-    let selected: Vec<_> = members
+    let eligible_members: Vec<_> = members // Filtering out bots and other ineligible members
         .into_iter()
         .filter(|m| {
             !m.user.bot
                 && (m.roles.contains(&RoleId::new(FIRST_YEAR_ROLE_ID))
                     || m.roles.contains(&RoleId::new(SECOND_YEAR_ROLE_ID)))
         })
-        .sample(&mut rand::rng(), 5);
+        .collect();
+
+    if eligible_members.is_empty() {
+        ctx.say("No eligible members found.").await?;
+        return Ok(());
+    }
+
+    let recent_picks = { // Accessing recently picked members to avoid repetition
+        let data = ctx.data();
+        let recent_random_picks = data.recent_random_picks.lock().unwrap();
+        recent_random_picks.clone()
+    };
+
+    let available_members: Vec<_> = eligible_members // Members who haven't been picked recently
+        .iter()
+        .filter(|member| !recent_picks.contains(&member.user.id))
+        .collect();
+
+    /* Since ThreadRng is not Send, keeping it alive across an .await causes command future to become non-Send.
+    So, we are enclosing the selection in it's own scope so the ThreadRng is dropped before we hit any .await, 
+    allowing the command future to remain Send
+     */
+
+    let selected = {  
+        let mut rng = rand::rng();
+
+        let mut selected: Vec<_> = available_members
+            .into_iter()
+            .sample(&mut rng, 5);
+
+        if selected.len() < 5 { // If not enough members are available, fetch recently picked members
+            let remaining_needed = 5 - selected.len();
+
+            let selected_ids: HashSet<UserId> =
+            selected.iter().map(|m| m.user.id).collect();
+
+            let additional: Vec<_> = eligible_members
+                .iter()
+                .filter(|m| !selected_ids.contains(&m.user.id))
+                .sample(&mut rng, remaining_needed);
+
+            selected.extend(additional);
+        }
+        selected 
+    };
 
     let ping_message = selected
         .iter()
         .map(|m| m.user.mention().to_string())
         .collect::<Vec<_>>()
         .join("\n");
 
-    ctx.say(format!("Pinging 5 members: {}", ping_message))
+    {
+        let data = ctx.data();
+        let mut recent_random_picks = data.recent_random_picks.lock().unwrap();
+        recent_random_picks.extend(selected.iter().map(|m| m.user.id)); // Adding selected members to recently picked set
+
+        let eligible_ids: HashSet<UserId> = eligible_members.iter().map(|m| m.user.id).collect(); 
+        recent_random_picks.retain(|user_id| eligible_ids.contains(user_id));
+        if recent_random_picks.len() >= eligible_ids.len() { // If all eligible members have been picked atleast once, clear the recently picked set
+            recent_random_picks.clear();
+        }
+    }
+    ctx.say(format!("Pinging {} members: {}", selected.len(), ping_message))
         .await?;
 
     Ok(())

src/main.rs

@@ -40,7 +40,10 @@ use serenity::{
 use trace::{setup_tracing, ReloadHandle};
 use tracing::{debug, info, instrument};
 
-use std::collections::HashMap;
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{Arc, Mutex},
+};
 
 type Error = Box<dyn std::error::Error + Send + Sync>;
 type Context<'a> = PoiseContext<'a, Data, Error>;
@@ -49,6 +52,7 @@ type Context<'a> = PoiseContext<'a, Data, Error>;
 #[derive(Clone)]
 struct Data {
     reaction_roles: HashMap<ReactionType, RoleId>,
+    recent_random_picks: Arc<Mutex<HashSet<UserId>>>,
     log_reload_handle: ReloadHandle,
     graphql_client: GraphQLClient,
 }
@@ -58,6 +62,7 @@ impl Data {
     fn new(reload_handle: ReloadHandle, root_url: String, api_key: String) -> Self {
         Data {
             reaction_roles: HashMap::new(),
+            recent_random_picks: Arc::new(Mutex::new(HashSet::new())),
             log_reload_handle: reload_handle,
             graphql_client: GraphQLClient::new(root_url, api_key),
         }