From 53227436d8d154aa0695d1c3ffddad37f69cb933 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Tue, 21 Jan 2025 22:48:35 +0100 Subject: [PATCH] Refactors IO and cleans up the add_roles function --- badges/coverage.svg | 2 +- src/io.rs | 597 ---------------------------------------- src/io/discord_calls.rs | 374 +++++++++++++++++++++++++ src/io/mod.rs | 181 ++++++++++++ src/io/utilities.rs | 102 +++++++ src/lib.rs | 14 +- src/main.rs | 3 +- 7 files changed, 666 insertions(+), 607 deletions(-) delete mode 100644 src/io.rs create mode 100644 src/io/discord_calls.rs create mode 100644 src/io/mod.rs create mode 100644 src/io/utilities.rs diff --git a/badges/coverage.svg b/badges/coverage.svg index 1a24f8b..4cf308c 100644 --- a/badges/coverage.svg +++ b/badges/coverage.svg @@ -1 +1 @@ -test-coverage: 88%test-coverage88% +test-coverage: 69%test-coverage69% diff --git a/src/io.rs b/src/io.rs deleted file mode 100644 index e63d049..0000000 --- a/src/io.rs +++ /dev/null @@ -1,597 +0,0 @@ -//! 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 std::collections::HashSet; - -use crate::modules::handler; -use crate::votes::EventHolder; -use distance::levenshtein; -use log::debug; -use poise::serenity_prelude as serenity; -use poise::serenity_prelude::RoleId; -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: Some("10 fev".to_owned()), - non_days: Some("10".to_owned()), - } - } -} - -/// 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 `needle` string and a vector of role names, and returns the closest match found. -/// If the input `needle` is None or the `haysack` vector is empty, the function will return None. -/// The search uses the Levenshtein distance algorithm to determine the similarity between strings. -/// -/// # Arguments -/// -/// * `needle` - An `Option` representing the target group name for which a match should be found. -/// * `haysack` - A vector of `String`s containing role names to compare against the target group name. -fn find_role_from_str(needle: Option<&str>, haysack: &Vec<&str>) -> Option { - if needle.is_none() || haysack.is_empty() { - return None; - } - - let group = needle.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 haysack { - let d = levenshtein(role, group); - if d < lowest.1 { - lowest = (Some(role), d); - }; - } - - lowest.0.map(|&s| s.to_owned()) -} - -fn find_roleid_from_str( - needle: Option<&str>, - haysack: &Vec<(&serenity::RoleId, &str)>, -) -> Option { - if needle.is_none() || haysack.is_empty() { - return None; - } - - let group = needle.unwrap(); - // We are hard-coding the maximum value above which we prefer returning None rather than a guess - let mut lowest = (None, 5); - for (roleid, role) in haysack { - let d = levenshtein(role, group); - if d < lowest.1 { - lowest = (Some(roleid), d); - }; - } - - lowest.0.map(|&s| *s) -} - -// /// 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 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, - #[description = "Date (optionelle) de début du vote"] start_date: Option, -) -> 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(()) -} -/// Parent command for all vote handling -/// -/// Can't be invoked, so left empty. -#[poise::command( - slash_command, - prefix_command, - subcommands("add_one", "remove_one", "add_many"), - subcommand_required -)] -pub async fn role(_: Context<'_>) -> Result<(), GenericError> { - Ok(()) -} - -/// Add one role from the list of all server roles. -/// -/// Add the role the user chose among the list and returns -/// an ephemeral as confirmation. Will return "Missing Permissions" -/// if the role asked is above the Bot's own role. -#[poise::command(slash_command, prefix_command)] -async fn add_one( - ctx: Context<'_>, - #[description = "Role"] role: serenity::Role, -) -> Result<(), GenericError> { - if ctx - .author() - .has_role(ctx, ctx.guild_id().unwrap(), &role) - .await? - { - ctx.defer_ephemeral().await?; - ctx.reply(format!("You already have the role {}.", &role)) - .await?; - } else { - ctx.http() - .add_member_role( - ctx.guild_id().unwrap(), - ctx.author().id, - role.id, - Some("Self requested."), - ) - .await?; - ctx.defer_ephemeral().await?; - ctx.reply(format!("Successfully added role {}.", &role)) - .await?; - } - Ok(()) -} - -#[poise::command(slash_command, prefix_command)] -async fn add_many( - ctx: Context<'_>, - #[description = "List of roles"] roles: String, -) -> Result<(), GenericError> { - debug!("{}", roles); - // let guild = ctx.guild().unwrap(); - let (roles_found, roles_not_found) = { - let fetched_list_of_server_roles = &ctx.guild().unwrap().roles; - // println!("{:?}", list_of_server_roles); - let list_of_roles = fetched_list_of_server_roles - .iter() - .map(|(roleid, role)| (roleid, role.name.as_str())) - .collect(); - // println!("{:?}", list_of_roles); - - let mut roles_found = HashSet::new(); - let mut roles_not_found = HashSet::new(); - for r in roles.split(",") { - if let Some(role) = find_roleid_from_str(Some(r), &list_of_roles) { - roles_found.insert(role); - } else { - roles_not_found.insert(r.to_string()); - }; - } - (roles_found, roles_not_found) - }; - // TODO: import banlist from config - // TODO: move this role prunning to before levenstein (find_role_from_str) - - println!("Roles found : {:?}", roles_found); - println!("Roles not found : {:?}", roles_not_found); - - // todo!(); - // TODO: Make this work - for r in roles_found { - ctx.http() - .add_member_role( - ctx.guild_id().unwrap(), - ctx.author().id, - r, - Some("User requested."), - ) - .await?; - } - - Ok(()) -} - -/// Remove one role from the list of all server roles. -/// -/// Removes the role the user chose among the list and returns -/// an ephemeral as confirmation. Will return "Missing Permissions" -/// if the role asked is above the Bot's own role. -#[poise::command(slash_command, prefix_command)] -async fn remove_one( - ctx: Context<'_>, - #[description = "Role"] role: serenity::Role, -) -> Result<(), GenericError> { - if ctx - .author() - .has_role(ctx, ctx.guild_id().unwrap(), &role) - .await? - { - ctx.http() - .remove_member_role( - ctx.guild_id().unwrap(), - ctx.author().id, - role.id, - Some("Self requested."), - ) - .await?; - ctx.defer_ephemeral().await?; - ctx.reply(format!("Successfully removed role {}.", &role)) - .await?; - } else { - ctx.defer_ephemeral().await?; - ctx.reply(format!("You do not have the role {}.", &role)) - .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(), - role(), - ], - ..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()) - ); - assert!(find_role_from_str(None, &arguments.to_vec()).is_none()); - assert!(find_role_from_str(Some("Bob"), &Vec::new()).is_none()); - } - - #[test] - fn create_container() { - VoteContainer::new( - "IO".to_string(), - "desc".to_string(), - VoteTypeIdentifier::WeeklyVote, - ); - } -} diff --git a/src/io/discord_calls.rs b/src/io/discord_calls.rs new file mode 100644 index 0000000..332f65e --- /dev/null +++ b/src/io/discord_calls.rs @@ -0,0 +1,374 @@ +//! 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. +//! +//! ### 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. + +#![allow(dead_code)] +use std::collections::HashSet; +use std::fmt::Write; + +use crate::error_handling::IdleError; +use crate::io::utilities::find_list_groups; +use crate::{ + io::{ + Context, Data, GenericError, InputRoleName, RoleFound, RoleIdTuple, VoteContainer, + VoteTypeIdentifier, WeeklyVoteModal, + }, + modules::handler, + votes::EventHolder, +}; +use log::info; +use poise::serenity_prelude::EditMember; +use poise::{serenity_prelude as serenity, Modal}; + +/// 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> { + use crate::io::utilities::find_roleid; + + 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_roleid( + &InputRoleName::StringName(underlying_data.group.unwrap()), + &guild.roles.iter().map(|(roleid,name)| (*roleid,name.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| { + // 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: {}",e), + ) // An inspect that could be used to signal something went wrong acquiring or applying the guild + .ok(); + + // TODO: Check this whole function + let serotoninenjoyer = VoteContainer { + title: underlying_data.title, + description: underlying_data.description, + group, + // hours: underlying_data.hours, + identifier: VoteTypeIdentifier::WeeklyVote, + ..Default::default() + }; + + handler(serotoninenjoyer); + }; + Ok(()) +} + +/// 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 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, + #[description = "Date (optionelle) de début du vote"] start_date: Option, +) -> 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(()) +} +/// Parent command for all vote handling +/// +/// Can't be invoked, so left empty. +#[poise::command( + slash_command, + prefix_command, + subcommands("add_one", "remove_one", "add_many"), + subcommand_required +)] +pub async fn role(_: Context<'_>) -> Result<(), GenericError> { + Ok(()) +} + +/// Add one role from the list of all server roles. +/// +/// Add the role the user chose among the list and returns +/// an ephemeral as confirmation. Will return "Missing Permissions" +/// if the role asked is above the Bot's own role. +#[poise::command(slash_command, prefix_command)] +async fn add_one( + ctx: Context<'_>, + #[description = "Role"] role: serenity::Role, +) -> Result<(), GenericError> { + if ctx + .author() + .has_role(ctx, ctx.guild_id().unwrap(), &role) + .await? + { + ctx.defer_ephemeral().await?; + ctx.reply(format!("You already have the role {}.", &role)) + .await?; + } else { + ctx.http() + .add_member_role( + ctx.guild_id().unwrap(), + ctx.author().id, + role.id, + Some("Self requested."), + ) + .await?; + ctx.defer_ephemeral().await?; + ctx.reply(format!("Successfully added role {}.", &role)) + .await?; + } + Ok(()) +} + +// TODO: Add doc +#[poise::command(slash_command, prefix_command)] +async fn add_many( + ctx: Context<'_>, + #[description = "List of roles"] roles: String, +) -> Result<(), GenericError> { + let roles_found: HashSet = find_list_groups(roles, &ctx.guild().unwrap().roles); + info!("Roles found : {:?}", roles_found); + + let mut existing_roles = ctx + .http() + .get_member(ctx.guild_id().unwrap(), ctx.author().id) + .await? + .roles; + let mut not_found_roles = Vec::new(); + + for role in roles_found { + match role { + RoleFound::FoundId(role_id) => { + if !existing_roles.contains(&role_id) { + existing_roles.push(role_id); + } + } + RoleFound::NotFound(name) => not_found_roles.push(name), + } + } + + ctx.guild_id() + .unwrap() + .edit_member( + ctx.http(), + ctx.author(), + EditMember::new().roles(&existing_roles), + ) + .await?; + + let mut status = format!("Your new roles are {:?}.", &existing_roles); + ctx.defer_ephemeral().await?; + if !not_found_roles.is_empty() { + write!( + status, + "\nThe following roles were not added as they couldn't be found {:?}.", + ¬_found_roles + )?; + } + ctx.reply(status).await?; + + Ok(()) +} + +/// Remove one role from the list of all server roles. +/// +/// Removes the role the user chose among the list and returns +/// an ephemeral as confirmation. Will return "Missing Permissions" +/// if the role asked is above the Bot's own role. +#[poise::command(slash_command, prefix_command)] +async fn remove_one( + ctx: Context<'_>, + #[description = "Role"] role: serenity::Role, +) -> Result<(), GenericError> { + if ctx + .author() + .has_role(ctx, ctx.guild_id().unwrap(), &role) + .await? + { + ctx.http() + .remove_member_role( + ctx.guild_id().unwrap(), + ctx.author().id, + role.id, + Some("Self requested."), + ) + .await?; + ctx.defer_ephemeral().await?; + ctx.reply(format!("Successfully removed role {}.", &role)) + .await?; + } else { + ctx.defer_ephemeral().await?; + ctx.reply(format!("You do not have the role {}.", &role)) + .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(), + role(), + ], + ..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 create_container() { + VoteContainer::new( + "IO".to_string(), + "desc".to_string(), + VoteTypeIdentifier::WeeklyVote, + ); + } +} diff --git a/src/io/mod.rs b/src/io/mod.rs new file mode 100644 index 0000000..a7d2937 --- /dev/null +++ b/src/io/mod.rs @@ -0,0 +1,181 @@ +//! The `ui` 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. +//! +//! It consists of several submodules: +//! +//! - `discord_calls`: Contains all functions that make direct calls to discord. +//! - `utilities`: Helper functions used in multiple places. +//! +//! # Functions +//! +//! The following functions are re-exported from the submodule `discord_calls`: +//! +//! - [discord_main_loop]: Starts the bot client and registers all command handlers. +//! - [create_new_vote]: Creates a new vote based on user input. +//! +//! # Examples +//! +//! ```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::votes::EventHolder; +use poise::serenity_prelude::RoleId; +use poise::serenity_prelude::{self as serenity}; + +pub mod discord_calls; +pub(crate) mod utilities; + +// Republish main function +pub use discord_calls::discord_main_loop; + +/// 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 tuple used internally to hold a RoleId and it's associated name close together +/// +/// Since a levenshtein function will be used on all members a HashMap cannot be used instead +type RoleIdTuple<'a> = (serenity::RoleId, &'a str); + +/// Describes a role either found in the context.roles or not found +#[derive(Debug, Hash, Eq, PartialEq)] +pub(crate) enum RoleFound { + /// Indicates a role was found + FoundId(RoleId), + /// Indicates a role couldn't be found + NotFound(String), +} + +/// An enum representing a parsed user input +/// +/// This input can either be: +/// - A `@Role`, translated by discord into a pseudo-user-id +/// - A `String`, giving the role name supposedly matching an existing role +pub(crate) enum InputRoleName { + /// A string representing an existing role + StringName(String), + /// An user id + IDName(RoleId), +} + +/// 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: Some("10 fev".to_owned()), + non_days: Some("10".to_owned()), + } + } +} diff --git a/src/io/utilities.rs b/src/io/utilities.rs new file mode 100644 index 0000000..b1a3666 --- /dev/null +++ b/src/io/utilities.rs @@ -0,0 +1,102 @@ +//! Utilities functions used to help interact with discord API calls +//! +//! This module provides utility functions related to finding roles in Discord based on user input. +//! It includes functions that compare strings using the Levenshtein distance algorithm to find the closest match. +//! +use std::collections::{HashMap, HashSet}; + +use distance::levenshtein; +use poise::serenity_prelude::{Role, RoleId}; + +use super::{InputRoleName, RoleFound, RoleIdTuple}; + +/// Find a roleid from user input either by passing the roleid parsed or trying to find one from the list of roles given in the haystack +pub(super) fn find_roleid(needle: &InputRoleName, haystack: &[RoleIdTuple]) -> Option { + match needle { + InputRoleName::StringName(name) => find_roleid_from_str(name, haystack), + InputRoleName::IDName(role_id) => Some(*role_id), + } +} + +/// Attempts to find the most closely matching RoleId from a list based on a provided group name. +/// +/// This function takes a `needle` string and a vector of , and returns the closest match found. +/// If the input `needle` is None or the `haystack` vector is empty, the function will return None. +/// The search uses the Levenshtein distance algorithm to determine the similarity between strings. +/// +/// # Arguments +/// +/// * `needle` - An `Option` representing the target group name for which a match should be found. +/// * `haystack` - A vector of `String`s containing role names to compare against the target group name. +pub(super) fn find_roleid_from_str(needle: &str, haystack: &[RoleIdTuple]) -> Option { + // We are hard-coding the maximum value above which we prefer returning None rather than a guess + let mut lowest = (None, 5); + for (roleid, role) in haystack { + let d = levenshtein(role, needle); + if d < lowest.1 { + lowest = (Some(roleid), d); + }; + } + lowest.0.copied() +} + +/// Find the list of groups that match the sting using the hashmap of existing role ids +/// +/// TODO: This function includes a banlist of group that can't be matched no matter what +pub(super) fn find_list_groups( + roles: String, + hashmap_roles: &HashMap, +) -> HashSet { + // TODO: import banlist from config + // TODO: move this role prunning to before levenstein (find_role_from_str) + // let fetched_list_of_server_roles = ; + let list_of_roles: Vec<(RoleId, &str)> = hashmap_roles + .iter() + .map(|(&roleid, role)| (roleid, role.name.as_str())) + .collect(); + // TODO: Use a parser to determine the wether it's an id or a String and use it instead of a split(",") + roles + .split(",") + .map(|role| match find_roleid_from_str(role, &list_of_roles) { + Some(role_id) => RoleFound::FoundId(role_id), + None => RoleFound::NotFound(role.to_string()), + }) + .collect() +} +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_find_roleid() { + let arguments = [ + (RoleId::new(3), "hunters"), + (RoleId::new(4), "ffxiv_idle"), + (RoleId::new(5), "ffxiv_progfish"), + (RoleId::new(6), "ffxiv_minilvl"), + (RoleId::new(7), "dbd"), + (RoleId::new(8), "dnd"), + (RoleId::new(9), "r6"), + (RoleId::new(10), "apex"), + (RoleId::new(11), "boardgames"), + ]; + assert!(find_roleid_from_str("bodyoncetoldme", &arguments).is_none()); + assert_eq!( + find_roleid_from_str("ffxivid", &arguments), + Some(RoleId::new(4)) + ); + assert_eq!( + find_roleid_from_str("hunte", &arguments), + Some(RoleId::new(3)) + ); + assert_eq!( + find_roleid_from_str("dbd", &arguments), + Some(RoleId::new(7)) + ); + assert_eq!( + find_roleid_from_str("ffxivpogfish", &arguments), + Some(RoleId::new(5)) + ); + assert!(find_roleid_from_str("Bob", &Vec::new()).is_none()); + } +} diff --git a/src/lib.rs b/src/lib.rs index 286284e..57450a2 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -9,16 +9,16 @@ //! #![warn(clippy::missing_docs_in_private_items)] -pub mod config; // Maybe in lib +pub mod config; // Maybe in lib pub mod date; // Definitely in lib -mod error_handling; // Likely in lib +mod error_handling; // Likely in lib pub mod ids; // Definitely in lib -pub mod io; // Maybe in lib -mod modules; // Maybe in lib -mod persistence; // Likely in lib -mod server; // Maybe in lib +pub mod io; // Maybe in lib +mod modules; // Maybe in lib +mod persistence; // Likely in lib +mod server; // Maybe in lib pub mod votes; // Likely in lib -mod watchdog; // Definitely in lib +mod watchdog; // Definitely in lib // // Re export // pub use votes::add_future_event; diff --git a/src/main.rs b/src/main.rs index e1b214b..43aae42 100644 --- a/src/main.rs +++ b/src/main.rs @@ -6,7 +6,6 @@ #![warn(clippy::missing_docs_in_private_items)] use idlefox::config::init_logger; -use idlefox::io::discord_main_loop; use idlefox::main_scheduler_loop; use tokio::time; @@ -25,5 +24,5 @@ async fn main() { time::interval(time::Duration::from_secs(5)), event_context.clone(), )); - discord_main_loop(event_context).await; + idlefox::io::discord_main_loop(event_context).await; }