diff --git a/Cargo.toml b/Cargo.toml
index 540c7d5..2403299 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -21,6 +21,7 @@ criterion = "0.5"
serde_json = { version = "1.0.132", features = ["alloc"] }
postcard = { version = "1.0.10", features = ["alloc"] }
ron = "0.8.1"
+distance = "0.4.0"
[profile.dev]
debug = 0
diff --git a/badges/coverage.svg b/badges/coverage.svg
index f21e8b5..5db7502 100644
--- a/badges/coverage.svg
+++ b/badges/coverage.svg
@@ -1 +1 @@
-
+
diff --git a/src/error_handling.rs b/src/error_handling.rs
index 04010cc..e9844d9 100644
--- a/src/error_handling.rs
+++ b/src/error_handling.rs
@@ -88,6 +88,18 @@ pub enum IdleError {
/// This is likely due to a thread being terminated but could also arise from a deadlock or a subtle race condition
#[error("An error happened while trying to acquire a mutex")]
MutexError,
+
+ /// Represents an error while acquiring a Discord group
+ ///
+ /// Raised when there is an error attempting to acquire the discord group
+ #[error("An error occured while tring to acquire the discord group: {0}")]
+ AcquiringDiscordGroup(String),
+
+ /// Indicates an error while acquiring Discord guilds
+ ///
+ /// This may happen when a function was called outside of the context of a server (likely a DM to the bot).
+ #[error("An error occured while tring to acquire discord guilds")]
+ AcquiringDiscordGuild,
}
impl From>> for IdleError {
diff --git a/src/io.rs b/src/io.rs
index c689cab..cdcd4ca 100644
--- a/src/io.rs
+++ b/src/io.rs
@@ -19,7 +19,14 @@
//! }
//! ```
//!
-use poise::serenity_prelude as serenity;
+#![allow(dead_code)]
+use crate::modules::handler;
+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 {}
@@ -28,13 +35,77 @@ 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,
+ /// Short name, used in voting titles
+ pub(crate) short_name: 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"]
-struct VoteCreation {
+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"]
@@ -52,10 +123,6 @@ struct VoteCreation {
#[name = "Nom du jeu"]
#[placeholder = "'FFXIV', 'MHW', 'D&D'..."]
short_name: Option,
- /// The title of the event
- #[name = "Titre"]
- #[placeholder = "Titre de votre événement"]
- title: 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"]
@@ -66,14 +133,14 @@ struct VoteCreation {
}
#[cfg(test)] // This default implementation only exists during testing
-impl Default for VoteCreation {
+impl Default for WeeklyVoteModal {
fn default() -> Self {
- VoteCreation {
+ 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()),
- title: "The base test vote".into(),
}
}
}
@@ -88,40 +155,100 @@ impl Default for VoteCreation {
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(underlying_data) = data {
+ log::info!(
+ "@{:?} **{:?}**\n{:?}\n{:?}, {:?}",
+ underlying_data.group,
+ underlying_data.title,
+ underlying_data.description,
+ underlying_data.short_name,
+ underlying_data.hours
+ );
- let data = VoteCreation::execute(ctx).await?;
- log::info!("Got data: {:?}", data);
- if let Some(unwrapped_data) = data {
- 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());
+ // 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 reply = poise::CreateReply::default().content(format!(
- "@{} **{}**\n{}\n{}, {}",
- group, title, description, short_name, hours
- ));
- ctx.send(reply).await?;
+ let serotoninenjoyer = VoteContainer {
+ title: underlying_data.title,
+ description: underlying_data.description,
+ group,
+ hours: underlying_data.hours,
+ short_name: underlying_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.
+/// Attempts to find the most closely matching role from a list based on a provided group name.
///
-/// 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,
+/// 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)]
@@ -131,17 +258,32 @@ pub async fn vote_command(
ctx: Context<'_>,
#[description = "Titre"] title: String,
#[description = "Nom du jeu"] short_name: Option,
- #[description = "Groupe"] group: ListOfRoles,
+ #[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> {
- ctx.say(format!(
- "{:?} ; {:?} ; {:?} ; {:?} ; {:?} ; {:?} ; {:?}",
- title, short_name, group, description, hours, start_date, non_days
- ))
- .await?;
+ let rhubarb = VoteContainer {
+ title,
+ description,
+ group,
+ hours,
+ short_name,
+ 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(())
}
@@ -155,17 +297,29 @@ pub async fn vote_command(
pub async fn short_vote(
ctx: Context<'_>,
#[description = "Titre"] title: String,
- #[description = "Groupe"] group: ListOfRoles,
+ #[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> {
- ctx.say(format!(
- "{:?} ; {:?} ; {:?} ; {:?} ; {:?} ; {:?}",
- title, group, description, hours, start_date, days
- ))
- .await?;
+ 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(())
}
@@ -184,18 +338,30 @@ pub async fn long_vote(
#[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> {
- ctx.say(format!(
- "{:?} ; {:?} ; {:?} ; {:?} ; {:?}",
- title, description, start_date, date_begin, date_end
- ))
- .await?;
+ 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 thsi loop aims to stay as simple as possible to be "self testing"
+// 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");
@@ -221,5 +387,41 @@ pub async fn discord_main_loop() {
#[cfg(test)]
mod tests {
- // use super::*;
+ 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())
+ );
+ }
}
diff --git a/src/lib.rs b/src/lib.rs
index 7294c63..3d186d3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,6 +7,7 @@
//!
//! The root module serves as a central entry point for users interested in using any part of the library.
//!
+#![warn(clippy::missing_docs_in_private_items)]
pub mod config; // Maybe in lib
pub mod date; // Definitely in lib
diff --git a/src/modules.rs b/src/modules.rs
index 2e936d2..85af193 100644
--- a/src/modules.rs
+++ b/src/modules.rs
@@ -5,6 +5,59 @@
//! Many handler functions
//! Every module encompassing a feature
+use crate::{
+ date::date_parse::DateObject,
+ io::{VoteContainer, VoteTypeIdentifier},
+};
+
+/// Handles generic VoteContainers, parses their data and feeds them into specific VoteObjects
+#[allow(unused_variables, unused_mut)]
+pub fn handler(vote_container: VoteContainer) {
+ // Following should be left as is
+ let title = vote_container.title;
+ let description = vote_container.description;
+ let group = vote_container.group;
+ let mut hours = vote_container.hours;
+ let mut start_date = vote_container.start_date;
+
+ // TODO: Give vky the tools to parse dates and time
+ // Needs to be parsed as start and end hours
+ let short_name = vote_container.short_name;
+ // Needs to be parsed as single date or set to today's date if None
+ let mut non_days = vote_container.non_days;
+ // Needs to be parsed as a list of days spanning one week after start_date
+ let mut days = vote_container.days;
+ // Needs to be parsed as a list of days spanning one week after start_date
+ let mut date_begin = vote_container.date_begin;
+ // Needs to be parsed as a single date
+ let mut date_end = vote_container.date_end;
+ // Needs to be parsed as a single date
+
+ match vote_container.identifier {
+ VoteTypeIdentifier::WeeklyVote => todo!(),
+ VoteTypeIdentifier::ShortVote => todo!(),
+ VoteTypeIdentifier::LongVote => todo!(),
+ VoteTypeIdentifier::Uninitialised => log::error!("Handler got an uninitialised vote."),
+ }
+}
+
+/// Parent structure for every vote
+#[allow(dead_code)]
+struct VoteObject {
+ /// Title of the event to vote for
+ title: String,
+ /// Description of the event to vote for
+ description: String,
+ /// Date from which on the vote should be published
+ start_date: DateObject,
+ /// Date after which the vote should be closed
+ close_date: DateObject,
+ /// Date after which the vote should be deleted from memory
+ delete_date: DateObject,
+}
+
+// TIL you can't do child structs on rust and now this pretty bit of code above is useless and I feel sad about it
+
#[cfg(test)]
mod tests {
// use super::*;
diff --git a/src/votes.rs b/src/votes.rs
index af6875d..650907d 100644
--- a/src/votes.rs
+++ b/src/votes.rs
@@ -314,11 +314,11 @@ impl Display for ParsedVote {
}
}
-// This split in two differents structs conceptually represents
-// the fact that very differents actions will be performed for each struct
+/// This split in two differents structs conceptually represents
+/// the fact that very differents actions will be performed for each struct
type EventListType = HashMap;
-// The list of pending events, not yet started
+/// The list of pending events, not yet started
///
/// This struct represents the collection of events that have been scheduled but have not yet begun.
#[derive(Serialize, Deserialize, Default)]