//! 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; //! //! #[tokio::main] //! async fn main() { //! discord_main_loop().await; //! } //! ``` //! use crate::modules::handler; use poise::serenity_prelude::{self as serenity}; /// User data, which is stored and accessible in all command invocations pub struct Data {} /// 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>; /// Generic object that is used to transfer vote data to other parts of the code. pub struct VoteContainer { title: String, description: String, group: Option, hours: Option, short_name: Option, start_date: Option, non_days: Option, days: String, date_begin: String, date_end: String, identifier: VoteTypeIdentifier, // ctx: Context<'_>, // Context needs a "lifetime" parameter, I have no idea what that is } /// 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() } } } /// Default is None impl Default for VoteContainer { fn default() -> Self { Self { title: "".to_string(), description: "".to_string(), group: None, hours: None, short_name: None, start_date: None, non_days: None, days: "".to_string(), date_begin: "".to_string(), date_end: "".to_string(), identifier: VoteTypeIdentifier::Uninitialised, } } } pub enum VoteTypeIdentifier { WeeklyVote, ShortVote, LongVote, 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 time a which the event shall take place #[name = "Horaires"] #[placeholder = "'21h - 23h' par défaut"] hours: Option, /// The name of the event #[name = "Nom du jeu"] #[placeholder = "'FFXIV', 'MHW', 'D&D'..."] short_name: Option, // Max fields is 5 so the two below will have to be command-exclusive // #[name = "Date de début du vote"] // #[placeholder = "'ven', '10', '21 jan', vide pour la prochaine période de votes"] // start_date: Option, // #[name = "Jours non dispos"] // #[placeholder = "'lun', '30', '2 dec'"] // non_days: 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()), hours: Some("21h - 23".into()), short_name: Some("Base vote".into()), } } } /// 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 poise::Modal as _; let data = WeeklyVoteModal::execute(ctx).await?; if let Some(unwrapped_data) = data { log::info!( "@{:?} **{:?}**\n{:?}\n{:?}, {:?}", unwrapped_data.group, unwrapped_data.title, unwrapped_data.description, unwrapped_data.short_name, unwrapped_data.hours ); log::info!("{:?}", ctx); // let group = unwrapped_data.group.unwrap_or("".into()); // let title = unwrapped_data.title; // let description = unwrapped_data.description; // let short_name = unwrapped_data.short_name.unwrap_or("".into()); // let hours = unwrapped_data.hours.unwrap_or("".into()); let serotoninenjoyer = VoteContainer { title: unwrapped_data.title, description: unwrapped_data.description, group: unwrapped_data.group, hours: unwrapped_data.hours, short_name: unwrapped_data.short_name, 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(()) } /// 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 = "Nom du jeu"] short_name: Option, #[description = "Groupe"] group: ListOfRoles, #[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, short_name, start_date, non_days, identifier: VoteTypeIdentifier::WeeklyVote, ..Default::default() }; handler(rhubarb); // 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: ListOfRoles, #[description = "Description"] description: String, #[description = "Horaires"] hours: Option, #[description = "Jours"] days: String, #[description = "Date de début du vote"] start_date: Option, ) -> Result<(), GenericError> { let aortavalve = VoteContainer { title, // group, description, hours, days, start_date, ..Default::default() }; handler(aortavalve); // 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> { let cartoy = VoteContainer { title, description, start_date, date_begin, date_end, ..Default::default() }; handler(cartoy); // 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() { 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 { poise::builtins::register_globally(ctx, &framework.options().commands).await?; Ok(Data {}) }) }) .build(); let client = serenity::ClientBuilder::new(token, intents) .framework(framework) .await; client.unwrap().start().await.unwrap(); } #[cfg(test)] mod tests { // use super::*; }