341 lines
12 KiB
Rust
341 lines
12 KiB
Rust
//! 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<dyn std::error::Error + Send + Sync>;
|
|
/// 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<String>,
|
|
hours: Option<String>,
|
|
short_name: Option<String>,
|
|
start_date: Option<String>,
|
|
non_days: Option<String>,
|
|
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<String>,
|
|
/// The time a which the event shall take place
|
|
#[name = "Horaires"]
|
|
#[placeholder = "'21h - 23h' par défaut"]
|
|
hours: Option<String>,
|
|
/// The name of the event
|
|
#[name = "Nom du jeu"]
|
|
#[placeholder = "'FFXIV', 'MHW', 'D&D'..."]
|
|
short_name: Option<String>,
|
|
// 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<String>,
|
|
// #[name = "Jours non dispos"]
|
|
// #[placeholder = "'lun', '30', '2 dec'"]
|
|
// non_days: Option<String>,
|
|
}
|
|
|
|
#[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<String>,
|
|
#[description = "Groupe"] group: ListOfRoles,
|
|
#[description = "Description"] description: String,
|
|
#[description = "Horaires"] hours: Option<String>,
|
|
#[description = "Date de début du vote"] start_date: Option<String>,
|
|
#[description = "Jours non dispos"] non_days: Option<String>,
|
|
) -> 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<String>,
|
|
#[description = "Jours"] days: String,
|
|
#[description = "Date de début du vote"] start_date: Option<String>,
|
|
) -> 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<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,
|
|
) -> 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::*;
|
|
}
|