//! Functions to handle I/O operations with Discord. //! //! This module contains functions for interacting with the Discord API, //! including receiving and sending messages, reactions, and managing channels and guilds. It also includes //! helper functions for performing advanced checks and validations on received data. //! ### Notes: //! - The code provided uses the Serenity and Poise frameworks to create a Discord bot that can interact with users through commands and modals. //! - The `discord_main_loop()` function starts the bot client and registers all command handlers, while the other functions handle specific tasks related to vote creation. //! - The `VoteCreation` struct is designed to be filled in by users through a modal form or text command arguments. It can then be used to create a new vote within the guild. //! //! ### Example usage: //! //! ```no_run //! use idlefox::io::discord_main_loop; //! use idlefox::votes::EventHolder; //! //! #[tokio::main] //! async fn main() { //! let ctx = EventHolder::default(); //! discord_main_loop(ctx).await; //! } //! ``` //! #![allow(dead_code)] use crate::modules::handler; use crate::votes::EventHolder; use distance::levenshtein; use poise::serenity_prelude::{self as serenity}; use poise::Modal as _; use crate::error_handling::IdleError; /// User data, which is stored and accessible in all command invocations pub struct Data { /// The global event holder event_holder: EventHolder, } /// A generic temporary serenity error type GenericError = Box; /// The context (in a discord sence) of a message type Context<'a> = poise::Context<'a, Data, GenericError>; /// A `VoteContainer` holds the details of a vote that is to be created. /// /// This struct aggregates all the necessary data describing this event within a Discord guild (server). /// Generic object that is used to transfer vote data to other parts of the code. #[derive(Default)] pub struct VoteContainer { /// The title of the event pub(crate) title: String, /// Description of the event pub(crate) description: String, /// An optional serenity::RoleId to specify the role group concerned by the vote. pub(crate) group: Option, /// Optional hours describing the specific date of the event pub(crate) hours: Option, /// Auto-Start date of the event (in human-readable format) pub(crate) start_date: Option, /// Days not selected for the vote pub(crate) non_days: Option, /// Days selected for the vote pub(crate) days: Option, /// Date the event begins pub(crate) date_begin: Option, /// Date the event ends pub(crate) date_end: Option, /// An identifier for the vote pub(crate) identifier: VoteTypeIdentifier, } /// Only title, description and identifier are mandatory impl VoteContainer { pub fn new(title: String, description: String, identifier: VoteTypeIdentifier) -> Self { Self { title, description, identifier, ..Default::default() } } } /// Identifies the type of the vote being created. /// /// This enum represents different types of votes, such as regular weekly votes, /// short-term votes, and long-term votes. It also serves as an indicator when a vote type /// hasn't been initialized yet. #[derive(Default)] pub enum VoteTypeIdentifier { // Represents a recurring weekly vote, with the list of days voted upon being one week WeeklyVote, /// Represents a short-term vote, that can be of any length and can be cast at any time without any form or plan. ShortVote, /// Represents a long-term vote, where the list of days voted upon extends beyond a week. LongVote, /// Indicates that the vote type has not been set yet, should only be used by default and is not a valid value. #[default] Uninitialised, } /// The result of a vote creation. /// /// This struct is used to store and display the results of creating a new vote via a discord modal form. #[derive(Debug, poise::Modal)] #[allow(dead_code)] // fields only used for Debug print #[name = "Créer un nouveau Vote"] pub(crate) struct WeeklyVoteModal { /// The title of the event #[name = "Titre"] #[placeholder = "Titre de votre événement"] title: String, /// The description of the event #[paragraph] #[name = "Description"] #[placeholder = "petite description de votre événement"] description: String, /// The group that will be tagged by the bot #[name = "Groupe"] #[placeholder = "groupe (sans le @)"] group: Option, /// The date from which the vote can become active #[name = "Date de début du vote"] #[placeholder = "'ven', '10', '21 jan', vide pour la prochaine période de votes"] start_date: Option, /// Days for which reactions should "not count" #[name = "Jours non dispos"] #[placeholder = "'lun', '30', '2 dec'"] non_days: Option, // Max fields is 5 so the two below will have to be command-exclusive // /// The time a which the event shall take place // #[name = "Horaires"] // #[placeholder = "'21h - 23h' par défaut"] // hours: Option, } #[cfg(test)] // This default implementation only exists during testing impl Default for WeeklyVoteModal { fn default() -> Self { WeeklyVoteModal { title: "The base test vote".into(), description: "Dummy vote".into(), group: Some("Base group".into()), start_date: todo!(), non_days: todo!(), } } } /// Creates a Discord Modal for a user-friendly vote creation form. /// /// This function triggers the creation of a modal that allows users to input details about an event they would like to organize. /// The input fields are predefined and include the title, short name of the game or event, group to tag, description, /// and hours at which the event will take place. #[cfg(not(tarpaulin_include))] // Async function only called by a foreign call #[poise::command(slash_command)] pub async fn vote_modal( ctx: poise::ApplicationContext<'_, Data, GenericError>, ) -> Result<(), GenericError> { let data = WeeklyVoteModal::execute(ctx).await?; if let Some(underlying_data) = data { log::info!( "@{:?} **{:?}**\n{:?}\n{:?}, {:?}", underlying_data.group, underlying_data.title, underlying_data.description, underlying_data.title, underlying_data.non_days ); // This whole shenennigan only exists to find a group as specified by text and if so apply it // However many steps can subtly break and cannot be truly accounted for let guild = ctx .guild() .ok_or_else(|| IdleError::AcquiringDiscordGuild)?; // Maybe the guild cannot be retrieved from the context, such as in a DM let group = find_role_from_str( underlying_data.group.as_deref(), guild.roles.values().map(|v| v.name.as_str()).collect(), ) .ok_or(IdleError::AcquiringDiscordGuild) // Maybe the guild doesn't exist or the match is too far or the group wasn't specified .and_then(|role_found: String| { guild .role_by_name(&role_found) .ok_or(IdleError::AcquiringDiscordGroup(role_found)) // Maybe somehow the group cannot be acquired by that name .map(|v| v.id) }) .inspect_err( |e| /* Do something when an error occurs*/ log::error!("An error occured when selecting groups from {:?}: {}",&underlying_data.group,e), ) // An inspect that could be used to signal something went wrong acquiring or applying the guild .ok(); let serotoninenjoyer = VoteContainer { title: underlying_data.title, description: underlying_data.description, group, // hours: underlying_data.hours, identifier: VoteTypeIdentifier::WeeklyVote, ..Default::default() }; handler(serotoninenjoyer); // let reply = poise::CreateReply::default().content(format!( // "@{} **{}**\n{}\n{}, {}", // group, title, description, short_name, hours // )); // ctx.send(reply).await?; }; Ok(()) } /// Attempts to find the most closely matching role from a list based on a provided group name. /// /// This function takes a `group` string and a vector of role names, and returns the closest match found. /// If the input `group` is None or the `roles` vector is empty, the function will return None. /// The search uses the Levenshtein distance algorithm to determine the similarity between strings. /// /// # Arguments /// /// * `group` - An `Option` representing the target group name for which a match should be found. /// * `roles` - A vector of `String`s containing role names to compare against the target group name. fn find_role_from_str(group: Option<&str>, roles: Vec<&str>) -> Option { if group.is_none() || roles.is_empty() { return None; } let group = group.unwrap(); // We are hard-coding the maximum value above which we prefer returning None rather than a guess let mut lowest = (None, 5); for role in roles { let d = levenshtein(role, group); if d < lowest.1 { lowest = (Some(role), d); }; } lowest.0.map(|s| s.to_owned()) } // /// List of choices for all the roles. // /// // /// This enum is used to define a set of predefined choices that users can select from when creating a new vote. // /// Each choice represents a role within the guild, and it can be referred to using the enum variant name. // #[derive(Debug, poise::ChoiceParameter)] // pub enum ListOfRoles { // // TODO: This needs to be a list of all guildRoles under Users (included) // // TODO: This needs to be fetched dynamically from the server // /// placeholder for a role // #[name = "hunters"] // Hunters, // } /// Text command for extensive vote creation // Since this is a discord command and not a real rust command, this many arguments is "normal" #[allow(clippy::too_many_arguments)] #[poise::command(prefix_command, slash_command)] #[cfg(not(tarpaulin_include))] // Async function only called by a foreign call pub async fn vote_command( ctx: Context<'_>, #[description = "Titre"] title: String, #[description = "Groupe"] group: Option, #[description = "Description"] description: String, #[description = "Horaires"] hours: Option, #[description = "Date de début du vote"] start_date: Option, #[description = "Jours non dispos"] non_days: Option, ) -> Result<(), GenericError> { let rhubarb = VoteContainer { title, description, group, hours, start_date, non_days, identifier: VoteTypeIdentifier::WeeklyVote, ..Default::default() }; let _ = ctx; handler(rhubarb); // TODO: Log and check that the handle does handle everything // ctx.say(format!( // "{:?} ; {:?} ; {:?} ; {:?} ; {:?} ; {:?} ; {:?}", // title, short_name, group, description, hours, start_date, non_days // )) // .await?; Ok(()) } /// Text command for the creation of exeptional votes ; outside normal voting windows. /// /// This text command is composed of optional group, hours and start_date ; and compulsory title, description and days. days will indicate which days of the week after the start_date will be available for voting. // Since this is a discord command and not a real rust command, this many arguments is "normal" #[allow(clippy::too_many_arguments)] #[poise::command(prefix_command, slash_command)] #[cfg(not(tarpaulin_include))] // Async function only called by a foreign call pub async fn short_vote( ctx: Context<'_>, #[description = "Titre"] title: String, #[description = "Groupe"] group: Option, #[description = "Description"] description: String, #[description = "Horaires"] hours: Option, #[description = "Jours"] days: String, #[description = "Date de début du vote"] start_date: Option, ) -> Result<(), GenericError> { handler(VoteContainer { title, group, description, hours, days: Some(days), start_date, ..Default::default() }); let _ = ctx; // TODO: Log and checks ? // ctx.say(format!( // "{:?} ; {:?} ; {:?} ; {:?} ; {:?} ; {:?}", // title, group, description, hours, start_date, days // )) // .await?; Ok(()) } /// Text command for the creation of long votes /// /// Text command for the creation of votes that span on a very long period to decide on dates for larger-scale events. /// Takes mandatory title, description, beginning and end date and optional starting date for the vote. #[allow(clippy::too_many_arguments)] // As this is not a real command by a discord command, there isn't really that many arguments #[poise::command(prefix_command, slash_command)] #[cfg(not(tarpaulin_include))] // Async function only called by a foreign call pub async fn long_vote( ctx: Context<'_>, #[description = "Titre"] title: String, #[description = "Description"] description: String, #[description = "Date de début du vote"] start_date: Option, #[description = "Date de début de la période de l'événement"] date_begin: String, #[description = "Date de fin de la période de l'événement"] date_end: String, ) -> Result<(), GenericError> { handler(VoteContainer { title, description, start_date, date_begin: Some(date_begin), date_end: Some(date_end), ..Default::default() }); let _ = ctx; // TODO: Log and checks ? // ctx.say(format!( // "{:?} ; {:?} ; {:?} ; {:?} ; {:?}", // title, description, start_date, date_begin, date_end // )) // .await?; Ok(()) } /// The main discord interaction loop /// /// Registers all functions and starts a bot client // As an async loop it is untestable by nature, however this loop aims to stay as simple as possible to be "self testing" #[cfg(not(tarpaulin_include))] pub async fn discord_main_loop(event_holder: EventHolder) { let token = std::env::var("DISCORD_TOKEN").expect("missing DISCORD_TOKEN"); let intents = serenity::GatewayIntents::non_privileged(); let framework = poise::Framework::builder() .options(poise::FrameworkOptions { commands: vec![vote_command(), vote_modal(), short_vote(), long_vote()], ..Default::default() }) .setup(|ctx, _ready, framework| { Box::pin(async move { event_holder.discord_ctx.lock().await.replace(ctx.clone()); poise::builtins::register_globally(ctx, &framework.options().commands).await?; Ok(Data { event_holder }) }) }) .build(); let client = serenity::ClientBuilder::new(token, intents) .framework(framework) .await; client.unwrap().start().await.unwrap(); } #[cfg(test)] mod tests { use super::*; #[test] fn test_levenshtein() { let arguments = [ "hunters", "ffxiv_idle", "ffxiv_progfish", "ffxiv_minilvl", "dbd", "dnd", "r6", "apex", "boardgames", ]; // println!("{:?}", arguments); // println!( // "{:?}", // find_role_from_str(Some("bodyoncetoldme"), arguments.to_vec()) // ); assert!(find_role_from_str(Some("bodyoncetoldme"), arguments.to_vec()).is_none()); assert_eq!( find_role_from_str(Some("ffxivid"), arguments.to_vec()), Some("ffxiv_idle".to_string()) ); assert_eq!( find_role_from_str(Some("hunte"), arguments.to_vec()), Some("hunters".to_string()) ); assert_eq!( find_role_from_str(Some("dbd"), arguments.to_vec()), Some("dbd".to_string()) ); assert_eq!( find_role_from_str(Some("ffxivpogfish"), arguments.to_vec()), Some("ffxiv_progfish".to_string()) ); } }