Compare commits

..

No commits in common. "dev" and "main" have entirely different histories.
dev ... main

32 changed files with 42 additions and 3897 deletions

19
.gitignore vendored
View File

@ -3,8 +3,6 @@
# will have compiled files and executables
debug/
target/
test/
bobito/
# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
@ -16,19 +14,8 @@ Cargo.lock
# MSVC Windows builds of rustc generate these, which store debugging information
*.pdb
# Added by cargo
/target
# The discord token
.token
# The coverage report
tarpaulin-report.html
# The log files
*.log
# A module summary
summary.md
config.json

View File

@ -1 +0,0 @@
badges/*

View File

@ -4,19 +4,6 @@ version = "0.1.0"
edition = "2021"
[dependencies]
poise = "0.6.1"
tokio = { version = "1.41.0", features = ["rt-multi-thread"] }
chrono = { version = "0.4.38", features = ["serde"] }
human_ids = "0.1.1"
serde = { version = "1.0.214", features = ["alloc", "derive"] }
thiserror = "1.0.65"
simplelog = { version = "0.12.2", features = ["paris"] }
log = { version = "0.4.22", features = ["std"] }
nom = "7.1.3"
criterion = "0.5"
serde_json = { version = "1.0.132", features = ["alloc"] }
ron = "0.8.1"
distance = "0.4.0"
[profile.dev]
debug = 0
@ -29,20 +16,3 @@ panic = "abort"
[lints.rust]
unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tarpaulin_include)'] }
[[bin]]
name = "idlefox"
path = "src/main.rs"
[lib]
name = "idlefox"
path = "src/lib.rs"
[dev-dependencies]
criterion = { version = "0.5", features = ["html_reports"] }
[[bench]]
name = "parser_benchmark"
harness = false

View File

@ -1,50 +0,0 @@
# List of commands and their inner workings
## `/vote_modal`
*Creates a new discord modal to walk the user through the creation of a new vote*
### Input
* title (String): The title for the futur event;
* short_name (Option<String>): Optional short name for the event;
* group (Option<String>): If specified, **must** be among the existing guildRoles in order for the bot to tag said guildRole;
* description (String): Description for the event;
* hours(Option<String>): Time window for the event.
### Output
> ## {title}
> @{group} {description}
> **{short_name} ; **{hours}**
Should the optional fields be left out, it could look like this:
> ## {title}
> {description}
> **21h - 23h**
## `/vote_command`
*More comprehensive, only-textual, version of vote_modal to create a new vote*
### Input
* title (String): The title for the futur event;
* short_name (Option<String>): Optional short name for the event;
* group (Option<String>): If specified, **must** be among the existing guildRoles in order for the bot to tag said guildRole;
* description (String): Description for the event;
* hours(Option<String>): Time window for the event;
* start_date(Option<String>): Date after which the bot will publish the vote in the first open-voting window (if it exists);
* non_days(Option<String>): Days for which the bot should replace the reaction from a number to a neutral emoji.
### Parsing logic
30/10/2024
> lun mar mer jeu ven sam dim
> le prochain jour qui correspond (a ce jour)
> ex: lun -> lun 4 nov
> 10, 21, 2
> le prochain jour qui correspond (a cette date)
> ex: 10 -> dim 10 nov
> 30 nov, 1 jan, 10 aou
> cette date exacte
> ex: 30 nov -> sam 30 nov
### Long votes
> Nouvel event!
> Description
> id: xxx
[Voter mes dispos] -> t'ouvre un modal
-> /dispo id: xxx date: 10 jan - 20 jan, 23 jan, 25 jan, 1 fev - 30 fev omit: 15 fev
-> /dispo id: xxx omit: 30 fev

326
Jenkinsfile vendored
View File

@ -1,326 +0,0 @@
// Add this webhook in Gitea:
// http://192.168.1.37:8080/gitea-webhook/post
pipeline {
agent { label 'rust_no_docker' }
environment {
CARGO_TERM_COLOR = 'always'
RUST_BACKTRACE = '1'
// CI gets its own Cargo home. This prevents ~/.cargo/config*
// from injecting host-specific linker options.
CARGO_HOME = "${WORKSPACE}/.ci-cargo-home"
// Keep CI artifacts separate from local/project builds.
CARGO_TARGET_DIR = "${WORKSPACE}/target-ci"
// Explicitly use the native FreeBSD compiler/linker.
CARGO_TARGET_X86_64_UNKNOWN_FREEBSD_LINKER = 'cc'
// Explicitly neutralize environment-provided Rust flags.
RUSTFLAGS = ''
CARGO_ENCODED_RUSTFLAGS = ''
}
stages {
stage('Checkout') {
steps {
checkout scm
sh '''
set -eu
git submodule sync --recursive
git submodule update --init --recursive
'''
}
}
stage('Setup Rust') {
steps {
sh '''
set -eu
if ! command -v rustup >/dev/null 2>&1; then
echo "ERROR: rustup is not installed on this worker." >&2
exit 1
fi
echo "Ensuring stable Rust is available..."
rustup toolchain install stable \
--profile minimal \
--component rustfmt \
--component clippy
rustup default stable
# ---------------------------------------------------------
# Prepare isolated Cargo environment
# ---------------------------------------------------------
rm -rf "${CARGO_HOME}"
mkdir -p "${CARGO_HOME}"
rm -rf "${CARGO_TARGET_DIR}"
mkdir -p "${CARGO_TARGET_DIR}"
# Cargo discovers .cargo/config* by walking upward from the
# current working directory. We therefore invoke Cargo from
# a neutral directory outside the repository.
CI_RUN_DIR="/tmp/idlefox-ci-${BUILD_NUMBER}"
rm -rf "${CI_RUN_DIR}"
mkdir -p "${CI_RUN_DIR}"
echo "${CI_RUN_DIR}" > .ci-run-dir
# ---------------------------------------------------------
# Information
# ---------------------------------------------------------
echo
echo "Rust:"
rustc --version
echo
echo "Cargo:"
cargo --version
echo
echo "rustfmt:"
rustfmt --version
echo
echo "Clippy:"
cargo clippy --version
echo
echo "Compiler:"
cc --version
echo
echo "Rust target:"
rustc -vV
echo
echo "Cargo home:"
echo "${CARGO_HOME}"
echo
echo "Cargo target directory:"
echo "${CARGO_TARGET_DIR}"
echo
echo "Neutral Cargo working directory:"
cat .ci-run-dir
echo
echo "Repository Cargo configuration files:"
find "${WORKSPACE}" \
-path '*/.cargo/config' \
-o \
-path '*/.cargo/config.toml' \
2>/dev/null || true
echo
echo "Any mold references in repository Cargo configuration:"
if [ -d "${WORKSPACE}/.cargo" ]; then
grep -Rni 'mold' "${WORKSPACE}/.cargo" || true
fi
echo
echo "CI linker:"
echo "${CARGO_TARGET_X86_64_UNKNOWN_FREEBSD_LINKER}"
'''
}
}
stage('Format') {
steps {
sh '''
set -eu
CI_RUN_DIR="$(cat "${WORKSPACE}/.ci-run-dir")"
cd "${CI_RUN_DIR}"
echo "Checking Rust formatting..."
cargo fmt \
--manifest-path "${WORKSPACE}/Cargo.toml" \
--all \
-- \
--check
'''
}
}
stage('Check') {
steps {
sh '''
set -eu
CI_RUN_DIR="$(cat "${WORKSPACE}/.ci-run-dir")"
cd "${CI_RUN_DIR}"
echo "Checking all IdleFox targets..."
cargo check \
--manifest-path "${WORKSPACE}/Cargo.toml" \
--all-targets \
--all-features
'''
}
}
stage('Test') {
steps {
sh '''
set -eu
CI_RUN_DIR="$(cat "${WORKSPACE}/.ci-run-dir")"
cd "${CI_RUN_DIR}"
echo "Running IdleFox tests..."
cargo test \
--manifest-path "${WORKSPACE}/Cargo.toml" \
--all-targets \
--all-features
'''
}
}
stage('Clippy') {
steps {
sh '''
set -eu
CI_RUN_DIR="$(cat "${WORKSPACE}/.ci-run-dir")"
cd "${CI_RUN_DIR}"
echo "Running Clippy..."
cargo clippy \
--manifest-path "${WORKSPACE}/Cargo.toml" \
--all-targets \
--all-features
'''
}
}
stage('Check Benchmarks') {
steps {
sh '''
set -eu
CI_RUN_DIR="$(cat "${WORKSPACE}/.ci-run-dir")"
cd "${CI_RUN_DIR}"
echo "Checking benchmark compilation..."
cargo check \
--manifest-path "${WORKSPACE}/Cargo.toml" \
--benches \
--all-features
'''
}
}
stage('Build Release') {
steps {
sh '''
set -eu
CI_RUN_DIR="$(cat "${WORKSPACE}/.ci-run-dir")"
cd "${CI_RUN_DIR}"
echo "Building IdleFox release..."
cargo build \
--manifest-path "${WORKSPACE}/Cargo.toml" \
--release \
--all-features
echo
echo "Release build completed."
BINARY="${CARGO_TARGET_DIR}/release/idlefox"
if [ ! -f "${BINARY}" ]; then
echo "ERROR: expected release binary was not produced:"
echo "${BINARY}"
exit 1
fi
echo
echo "Release binary:"
ls -lh "${BINARY}"
echo
echo "Binary type:"
file "${BINARY}" || true
'''
}
}
}
post {
success {
publishChecks(
conclusion: 'SUCCESS',
name: 'Rust CI',
summary: 'IdleFox passed all CI checks.',
text: 'Formatting, compilation checks, tests, Clippy, benchmark compilation, and release build completed successfully using the native FreeBSD linker.',
title: 'Build Successful'
)
echo '✅ IdleFox passed all CI checks.'
}
failure {
publishChecks(
conclusion: 'FAILURE',
name: 'Rust CI',
summary: 'IdleFox failed CI.',
text: 'Formatting, compilation, tests, Clippy, benchmarks, or the release build failed. Check the Jenkins log.',
title: 'Build Failed'
)
echo '❌ IdleFox CI failed.'
}
unstable {
publishChecks(
conclusion: 'ACTION_REQUIRED',
name: 'Rust CI',
summary: 'IdleFox CI is unstable.',
text: 'The Jenkins build completed with an unstable status.',
title: 'Build Unstable'
)
echo '⚠️ IdleFox CI is unstable.'
}
always {
sh '''
echo "Cleaning IdleFox CI environment..."
if [ -f .ci-run-dir ]; then
CI_RUN_DIR="$(cat .ci-run-dir)"
rm -rf "${CI_RUN_DIR}"
fi
rm -f .ci-run-dir
rm -rf .ci-cargo-home
# Keep target-ci for now so Jenkins retains incremental
# compilation between builds. Uncomment to make every build
# completely clean:
#
# rm -rf target-ci
'''
}
}
}

View File

@ -1,46 +1,7 @@
# idlefox
![code coverage](badges/coverage.svg) ![version](badges/version.svg) ![code coverage](badges/test.svg)
IdleFox is a feature-rich Discord bot designed to streamline the process of finding meeting dates, organizing events, and making decisions among multiple options. With its user-friendly commands and robust command system, IdleFox helps facilitate effective communication within server communities.
### Key Features
- **Advanced Date Handling**: IdleFox offers robust date parsing and manipulation, supporting complex date formats and context-aware conversions.
- **Find Meeting Dates**: Easily coordinate with your community through reaction-voting for dates.
- **Event Organization**: Start events to organize group activities, meetups, or campaigns.
- **Decision Making**: Use the bot's voting functionalities to make informed decisions among multiple options.
- **Vote Management**: Keep track of ongoing votes and manage their lifecycle from initiation to closure.
- **Vote Organization**: Delays vote posting and allows continuous editing of answers as time progresses.
- **Web Interface**: Provides monitoring of all activities and enables admins to close votes through a web interface.
## Bot Components
- `main.rs`: Initializes logging and starts the main loop for handling Discord interactions.
- `config.rs`: Manages configuration settings for the bot, ensuring data persistence and recovery.
- `date/`: Provides functionalities for date parsing, conversion, and manipulation.
- `dateparse.rs`: Parses input strings into date objects using nom parsers.
- `date_tools.rs`: Transforms dates into more precise formats based on context.
- `io.rs`: Interacts with Discord through Serenity and Poise libraries to handle commands and events.
- `votes.rs`: Manages event and vote data structures, enabling voting functionality within Discord servers.
- `persistence.rs`: Ensures data persistence and integrity between bot runs.
- `server.rs`: Provides server-related functionalities, such as displaying votes and closing ongoing votes.
- `modules.rs`: Aggregates various voting logic functions into a single module for easier management and use within the application. This includes decision-making features beyond simple vote counting.
- `error_handling.rs`: Handles error reporting and logging, ensuring that any issues encountered by the bot are appropriately recorded and reported.
A great emphasis is put on organizing the votes themselves, delaying posting them and editing the answers as time goes.
This bot also spins a web interface to allow real time monitoring of all activities and (for admins) close the votes via said interface
## List of commands
* `/vote_modal` Pops up a modal (discord form) helping the user through creating a vote.
* `/vote_command` Comprehensive text command for creating a vote.
* `/vote_short` Creates an exceptional (non-weekly) vote. This is used for events outside of the normal voting window and can't go above 7 days-options.
* `/vote_long` Creates a vote for a long period of time (from 8 days to 12 months). This is used for important events that must be planned extremely long in advance.
### Contributing
IdleFox welcomes contributions from the community. To contribute, fork the repository, make your changes, and submit a pull request for review.
### License
This project is licensed under the MIT License. For more information, see the LICENSE file.
A Rust Discord Bot, in charge of greatly simplifying the process of finding a meeting date, organising an event and choosing between several options.
A great emphasis is put on organizing the votes themselves, delaying posting them and editing the answers as time goes.
This bot also spins a web interface to allow real time monitoring of all activities and (for admins) close the votes via said interface

View File

@ -1 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="122" height="18" role="img" aria-label="test-coverage: 88%"><title>test-coverage: 88%</title><linearGradient id="bms-7f01f1ef66d48313" x2="0" y2="100%"><stop offset="0" stop-color="#fff" stop-opacity=".7"/><stop offset=".1" stop-color="#aaa" stop-opacity=".1"/><stop offset=".9" stop-color="#000" stop-opacity=".3"/><stop offset="1" stop-color="#000" stop-opacity=".5"/></linearGradient><clipPath id="bmr-7f01f1ef66d48313"><rect width="122" height="18" rx="4" fill="#fff"/></clipPath><g clip-path="url(#bmr-7f01f1ef66d48313)"><rect width="87" height="18" fill="#555"/><rect x="87" width="35" height="18" fill="#fe7d37"/><rect width="122" height="18" fill="url(#bms-7f01f1ef66d48313)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="445" y="140" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="770">test-coverage</text><text x="445" y="130" transform="scale(.1)" fill="#fff" textLength="770">test-coverage</text><text aria-hidden="true" x="1035" y="140" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="250">88%</text><text x="1035" y="130" transform="scale(.1)" fill="#fff" textLength="250">88%</text></g></svg>

Before

Width:  |  Height:  |  Size: 1.3 KiB

View File

@ -1 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="82" height="18" role="img" aria-label="test: passing"><title>test: passing</title><linearGradient id="bms-5402c39dce014bd3" x2="0" y2="100%"><stop offset="0" stop-color="#fff" stop-opacity=".7"/><stop offset=".1" stop-color="#aaa" stop-opacity=".1"/><stop offset=".9" stop-color="#000" stop-opacity=".3"/><stop offset="1" stop-color="#000" stop-opacity=".5"/></linearGradient><clipPath id="bmr-5402c39dce014bd3"><rect width="82" height="18" rx="4" fill="#fff"/></clipPath><g clip-path="url(#bmr-5402c39dce014bd3)"><rect width="31" height="18" fill="#555"/><rect x="31" width="51" height="18" fill="#97ca00"/><rect width="82" height="18" fill="url(#bms-5402c39dce014bd3)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="165" y="140" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="210">test</text><text x="165" y="130" transform="scale(.1)" fill="#fff" textLength="210">test</text><text aria-hidden="true" x="555" y="140" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="410">passing</text><text x="555" y="130" transform="scale(.1)" fill="#fff" textLength="410">passing</text></g></svg>

Before

Width:  |  Height:  |  Size: 1.3 KiB

View File

@ -1 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="90" height="18" role="img" aria-label="version: 0.1.0"><title>version: 0.1.0</title><linearGradient id="bms-0431e50b7af7883f" x2="0" y2="100%"><stop offset="0" stop-color="#fff" stop-opacity=".7"/><stop offset=".1" stop-color="#aaa" stop-opacity=".1"/><stop offset=".9" stop-color="#000" stop-opacity=".3"/><stop offset="1" stop-color="#000" stop-opacity=".5"/></linearGradient><clipPath id="bmr-0431e50b7af7883f"><rect width="90" height="18" rx="4" fill="#fff"/></clipPath><g clip-path="url(#bmr-0431e50b7af7883f)"><rect width="51" height="18" fill="#555"/><rect x="51" width="39" height="18" fill="#fe7d37"/><rect width="90" height="18" fill="url(#bms-0431e50b7af7883f)"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text aria-hidden="true" x="265" y="140" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="410">version</text><text x="265" y="130" transform="scale(.1)" fill="#fff" textLength="410">version</text><text aria-hidden="true" x="695" y="140" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="290">0.1.0</text><text x="695" y="130" transform="scale(.1)" fill="#fff" textLength="290">0.1.0</text></g></svg>

Before

Width:  |  Height:  |  Size: 1.3 KiB

View File

@ -1,23 +0,0 @@
use chrono::NaiveDate;
use criterion::{criterion_group, criterion_main, Criterion};
use idlefox::date::parse_date_list;
use std::hint::black_box;
fn complex_date_parse(input: &str) -> usize {
let context = NaiveDate::from_ymd_opt(2023, 10, 1);
let list = parse_date_list(input, context).unwrap();
list.len()
}
fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("complex_date_parse", |b| {
b.iter(|| {
complex_date_parse(black_box(
"Oct 5, Nov 15 - 18, sat, mon , tue-fri and some other text",
))
})
});
}
criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);

View File

@ -1 +0,0 @@
MTMwMDc2ODk2MTgwNTI5MTUzMA.GlMP_L.PU1953SsJ-8naI2rXSRLZuZw1jzV7CgckYtOSk

View File

@ -1,234 +0,0 @@
//! # IdleFox Configuration Module
//!
//! This module provides a centralized configuration system for IdleFox, allowing you to load and manage your settings in an efficient and flexible manner.
//!
//! The primary goal of this module is to provide a robust and reliable way to store and retrieve configuration data from the `config.json` file.
//! If the file does not exist or cannot be loaded, it will automatically create a default version for you.
//!
//! ### Key Features
//!
//! * **Config Loading**: Seamlessly load your existing config from the `config.json` file, ensuring that all settings are preserved and up-to-date.
//! * **Default Config Creation**: Automatically generate a default configuration if the specified file cannot be loaded or is missing.
//! * **Legacy Data Import**: Safely import old data from outdated configurations to minimize disruptions during upgrades.
//! * **Faulty Data Recovery**: Implement measures to recover from importing faulty data, ensuring that your IdleFox instance remains stable and functional.
//!
//! ### Usage
//!
//! To use this module effectively, you can follow these steps:
//!
//! 1. Use the `init_logger()` function from the IdleFox logging module (as shown below) to initialize the logger with your custom log level and output destination.
//!
//! Example usage:
//!
//! ```rust
//! # use idlefox::config;
//! # fn main() {
//! // Initialize the logger with a custom log level of info
//! config::init_logger().expect("Failed to initialize logger");
//! // Log some messages at different levels (e.g., debug, warn, error)
//! let message = "This is an example message";
//! log::warn!("{}", message);
//! log::error!("{}", message);
//! # }
//!
#![allow(clippy::all)]
use crate::IdleError;
use std::{fs::File, io::Write};
use log::LevelFilter;
use poise::serenity_prelude::{EmojiId, ReactionType};
use serde::{Deserialize, Serialize};
use simplelog::{ColorChoice, CombinedLogger, Config, TermLogger, TerminalMode, WriteLogger};
pub type WeeklyReactionList = Vec<ReactionType>;
/// A structure representing the global configuration for a Discord bot.
///
/// This struct contains various settings and parameters that influence how the bot
/// operates, such as which type of reaction is selected to indicate different days
/// in a weekly schedule, and custom emotes or Unicode characters used for reactions.
#[derive(Serialize, Deserialize)]
pub struct GlobalConfig {
/// The type of reaction selected by the user. Either the default unicode emote or a custom set of emotes.
selected_reaction: SelectedReaction,
/// The list of 7 weekly emotes to use as reaction to indicate the weekly days.
custom_weekly_emotes: WeeklyReactionList,
/// The list of 7 weekly unicode emotes to use as reaction to indicate the weekly days.
custom_weekly_unicode: WeeklyReactionList,
}
impl Default for GlobalConfig {
fn default() -> Self {
GlobalConfig {
selected_reaction: SelectedReaction::Emotes,
custom_weekly_emotes: Self::emotes(),
custom_weekly_unicode: Self::unicode(),
}
}
}
impl GlobalConfig {
/// Try to load the config from disk and return a default config if none is found
pub fn try_load_from_disk() -> Result<GlobalConfig, IdleError> {
// let f = File::open("config.json").map_err(IdleError::LoadingConfig)?;
if let Ok(f) = File::open("config.json") {
Ok(serde_json::from_reader(f).map_err(IdleError::SerdeError)?)
} else {
Ok(GlobalConfig::default())
}
}
/// Try to save the config to disk
// Testing a bad serialisation is pointless
#[cfg(not(tarpaulin_include))]
pub fn try_save_to_disk(&self) -> Result<(), IdleError> {
let mut f = File::create("config.json").map_err(IdleError::SavingConfig)?;
f.write_all(
serde_json::to_string_pretty(&self)
.map_err(IdleError::SerdeError)?
.as_bytes(),
)
.map_err(IdleError::SavingConfig)?;
Ok(())
}
/// Generate the custom emote variant of the reactions
#[cfg(not(tarpaulin_include))]
fn emotes() -> WeeklyReactionList {
vec![
ReactionType::Custom {
animated: false,
id: EmojiId::new(1329486629961859154),
name: Some("Lu".to_string()),
},
ReactionType::Custom {
animated: false,
id: EmojiId::new(1329486631182405642),
name: Some("Ma".to_string()),
},
ReactionType::Custom {
animated: false,
id: EmojiId::new(1329486632352612424),
name: Some("Me".to_string()),
},
ReactionType::Custom {
animated: false,
id: EmojiId::new(1329486628409835642),
name: Some("Je".to_string()),
},
ReactionType::Custom {
animated: false,
id: EmojiId::new(1329486635087302737),
name: Some("Ve".to_string()),
},
ReactionType::Custom {
animated: false,
id: EmojiId::new(1329486633271169107),
name: Some("Sa".to_string()),
},
ReactionType::Custom {
animated: false,
id: EmojiId::new(1329486626023276604),
name: Some("Di".to_string()),
},
]
}
/// Generate the unicode variant of the reactions
fn unicode() -> WeeklyReactionList {
vec![
ReactionType::Unicode("1️⃣".to_string()),
ReactionType::Unicode("2️⃣".to_string()),
ReactionType::Unicode("3️⃣".to_string()),
ReactionType::Unicode("4️⃣".to_string()),
ReactionType::Unicode("5️⃣".to_string()),
ReactionType::Unicode("6️⃣".to_string()),
ReactionType::Unicode("7️⃣".to_string()),
]
}
}
/// The type of reaction to use
#[derive(Serialize, Deserialize)]
enum SelectedReaction {
/// Use the custom emotes provided
Emotes,
/// Use the default unicode one
Unicode,
}
/// Initializes a logger for logging purposes.
///
/// This function sets up two loggers: one for terminal output (with warning level) and another for file-based logging (with info level).
///
/// The terminal logger will display warnings, while the file logger will write all logs at or above the info level to an "idlefox.log" file in the current working directory.
///
/// # Examples
///
/// ```
/// idlefox::config::init_logger().expect("Failed to initialize logger");
/// // Log a message at the info level.
/// log::info!("This will be written to idlefox.log");
///
/// // Log a warning at the warn level, which should appear on screen as well.
/// log::warn!("Warning: This will be written on file and on screen");
/// ```
///
#[cfg(not(tarpaulin_include))]
pub fn init_logger() -> Result<(), IdleError> {
CombinedLogger::init(vec![
TermLogger::new(
LevelFilter::Warn,
Config::default(),
TerminalMode::Mixed,
ColorChoice::Auto,
),
WriteLogger::new(
LevelFilter::Info,
Config::default(),
// TODO: Maybe add la date du jour de lancement ?
File::create("idlefox.log").unwrap(),
),
])
.map_err(IdleError::LoggerInitFailure)
}
#[cfg(test)]
mod tests {
use std::fs;
use poise::serenity_prelude::ReactionType;
use super::GlobalConfig;
#[test]
fn test_default_cfg() {
let d = GlobalConfig::default();
assert!(d.custom_weekly_emotes.len() >= 7);
assert!(d.custom_weekly_unicode.len() >= 7);
for e in d.custom_weekly_emotes {
if let ReactionType::Custom {
animated,
id: _,
name,
} = e
{
assert_eq!(animated, false);
assert!(name.is_some());
}
}
}
#[test]
fn test_save_cfg() {
let c = GlobalConfig::default();
let try_save_to_disk = c.try_save_to_disk();
assert!(try_save_to_disk.is_ok());
}
#[test]
fn test_load_cfg() {
let _ = fs::remove_file("config.json");
let try_load_from_disk = GlobalConfig::try_load_from_disk();
assert!(try_load_from_disk.is_ok());
}
}

View File

@ -1,406 +0,0 @@
//! The module provides functions for parsing date strings into Rust structs.
//! The pseudo grammar is defined as:
//! ```py
//! date = (day) (month) | (month) (day) | (weekday)
//! daterange = (date) - (date)
//! dateobject = (date) | (daterange)
//! datelist = (dateobject) (, (dateobject))*
//! ```
//! All strings parsed will be parsed into a [DateList], as the function [parse_str_into_date] always assume you are providing it a list of ranges.
//! Parsing a single date is outside of the scope of this module and should be implemented separately if needed.
//!
//! Please note that while an invalid input will return an error, a partially valid input will yield partial results.
//!
//! # Functions
//! The following functions are used to parse user data:
//! * [parse_simple_date]
//! ### Usage
//! ```
//! use idlefox::date::parse_str_into_date;
//! let result = parse_str_into_date("12 dec - 23 feb, lun - mer, 12, 14");
//!
//! // Parses into 12 dec - 23 feb
//! let partial_result = parse_str_into_date("12 dec - 23 febelunmer");
//! ```
#![allow(dead_code)]
use chrono::{Month, Weekday};
use nom::{
branch::alt,
bytes::complete::tag_no_case,
character::complete::{char, digit1, space0},
combinator::{map, value},
multi::separated_list1,
sequence::{delimited, separated_pair, tuple},
IResult, ParseTo,
};
/// The DatePoint enum represents a single relative date, which can be either a day and an optional month or a weekday.
///
/// ### Parsing
/// The date is parsed from the following formats:
/// * ``Day (Month)?`` - with ``Day`` as a day as a ``(\d)+`` and month as a two or three letter str. Specifies a day and an optional month.
/// * ``WeekDay`` - with ``WeekDay`` as a three letter str. Specifies a weekday.
///
/// ### Data Structure
/// * Date: Represents a day specified by its position in the month, along with an optional month.
/// * day: The day of the month.
/// * month: An optional Month enum value (see [chrono::Month]).
/// * Weekday: Represents a Weekday (as in Mon, Tue, etc.). (see [chrono::Weekday])
///
/// ### Examples
/// ```
/// # use chrono::{Month, Weekday};
/// # use idlefox::date::date_parse::DatePoint;
/// // Manually create a date with day and month
/// let date_point1 = DatePoint::Date { day: 15, month: Some(Month::January) };
/// // Manually create a weekday
/// let date_point3 = DatePoint::Weekday(Weekday::Mon);
/// ```
#[derive(Debug, Clone, Copy)]
#[cfg_attr(test, derive(PartialEq))]
pub enum DatePoint {
/// A day specified by it's position in the month, and an optionnal month
Date {
/// The day of the month
day: u32,
/// An optional month
month: Option<Month>,
},
/// A weekday (as in Mon, Tue, etc..)
Weekday(Weekday),
}
/// The DateRange struct represents a date range, encompassing a starting point and an endpoint.
///
/// ### Parsing
/// The date range is parsed from the following format:
/// * ``DatePoint - DatePoint`` - with DatePoint as a [DatePoint]
///
/// ### Data Structure
/// • start: The starting date in the range.
/// • stop: The end date in the range.
/// ### Examples
/// ```
/// # use chrono::Month;
/// # use idlefox::date::date_parse::{DatePoint, DateRange};
/// // Create a date range from two DatePoint values
/// let date_range = DateRange {
/// start: DatePoint::Date { day: 1, month: Some(Month::January) },
/// stop: DatePoint::Date { day: 31, month: Some(Month::December) },
/// };
/// ```
#[derive(Clone, Debug)]
#[cfg_attr(test, derive(PartialEq))]
pub struct DateRange {
/// The starting date in the range
pub start: DatePoint,
/// The end date in the range
pub stop: DatePoint,
}
/// The DateObject enum represents the main date structure, which can be either a date range or a single date.
///
/// ### Parsing
/// The date object is parsed from the following formats:
/// * [DateRange]: Represents a range between two relative dates.
/// * [DatePoint]: Represents a single date.
///
///
/// ### Examples
/// ```
/// # use chrono::Month;
/// # use idlefox::date::date_parse::{DateObject, DatePoint, DateRange};
/// // Create a DateObject representing a range
/// let date_object1 = DateObject::Range(DateRange {
/// start: DatePoint::Date { day: 1, month: Some(Month::January) },
/// stop: DatePoint::Date { day: 31, month: Some(Month::December) },
/// });
///
/// // Create a DateObject representing a single date
/// let date_object2 = DateObject::Single(DatePoint::Date { day: 15, month: Some(Month::February) });
/// ```
#[derive(Clone, Debug)]
#[cfg_attr(test, derive(PartialEq))]
pub enum DateObject {
/// A range between two relative dates
Range(DateRange),
/// A single date
Single(DatePoint),
}
// struct DateList {
// inner: Vec<DateObject>,
// }
/// The DateList type represents a list of dates, which can contain either single dates or date ranges.
///
/// ### Parsing
/// The date list is parsed from the following format:
/// * ``DateObject (, DateObject)*`` - with ``DateObject`` as a [DateObject]
///
/// ### Data Structure
/// A vector of DateObject elements.
///
/// ### Examples
/// ```
/// # use chrono::Month;
/// # use idlefox::date::date_parse::{DateList, DateObject, DatePoint, DateRange};
/// // Create a DateList with a single date and a range
/// let date_list = DateList::from(vec![
/// DateObject::Single(DatePoint::Date {
/// day: 15,
/// month: Some(Month::January),
/// }),
/// DateObject::Range(DateRange {
/// start: DatePoint::Date {
/// day: 1,
/// month: Some(Month::February),
/// },
/// stop: DatePoint::Date {
/// day: 28,
/// month: Some(Month::February),
/// },
/// }),
/// ]);
/// ```
pub type DateList = Vec<DateObject>;
/// The parse_month function parses a month from a given input string. It supports both French and English denominations.
///
/// ### Parsing Logic
/// The function uses the [nom::branch::alt] combinator to handle both French and English month denominations.
/// Each denomination is represented by an alt combinator that matches the corresponding month value.
fn parse_month(input: &str) -> IResult<&str, Month> {
alt((
alt((
value(Month::January, tag_no_case("jan")),
value(Month::February, tag_no_case("fev")),
value(Month::February, tag_no_case("feb")),
value(Month::March, tag_no_case("mar")),
value(Month::March, tag_no_case("avr")),
value(Month::April, tag_no_case("apr")),
value(Month::May, tag_no_case("mai")),
value(Month::May, tag_no_case("may")),
value(Month::June, tag_no_case("juin")),
value(Month::June, tag_no_case("jun")),
value(Month::July, tag_no_case("juil")),
value(Month::July, tag_no_case("jul")),
value(Month::August, tag_no_case("aou")),
value(Month::August, tag_no_case("aug")),
value(Month::September, tag_no_case("sep")),
value(Month::October, tag_no_case("oct")),
value(Month::November, tag_no_case("nov")),
value(Month::December, tag_no_case("dec")),
)),
alt((
value(Month::January, tag_no_case("jr")),
value(Month::February, tag_no_case("fr")),
value(Month::March, tag_no_case("ms")),
value(Month::April, tag_no_case("al")),
value(Month::May, tag_no_case("mi")),
value(Month::June, tag_no_case("jn")),
value(Month::July, tag_no_case("jt")),
value(Month::August, tag_no_case("at")),
value(Month::September, tag_no_case("se")),
value(Month::October, tag_no_case("oe")),
value(Month::November, tag_no_case("ne")),
value(Month::December, tag_no_case("de")),
)),
))(input)
}
/// The parse_weekday function parses a weekday from a given input string.
/// It supports both French and English weekday abbreviations.
///
/// ### Parsing Logic
/// The function uses the [nom::sequence::delimited] combinator to remove leading and trailing spaces from the input string.
/// Inside the delimiter, it uses the [nom::branch::alt] combinator to match any of the supported weekday abbreviations.
///
/// ### Errors
/// Will return an Error if the input can't be matched to a day
fn parse_weekday(input: &str) -> IResult<&str, Weekday> {
delimited(
space0,
alt((
value(Weekday::Mon, tag_no_case("mon")),
value(Weekday::Mon, tag_no_case("lun")),
value(Weekday::Tue, tag_no_case("tue")),
value(Weekday::Tue, tag_no_case("mar")),
value(Weekday::Wed, tag_no_case("wed")),
value(Weekday::Wed, tag_no_case("mer")),
value(Weekday::Thu, tag_no_case("thu")),
value(Weekday::Thu, tag_no_case("jeu")),
value(Weekday::Fri, tag_no_case("fri")),
value(Weekday::Fri, tag_no_case("ven")),
value(Weekday::Sat, tag_no_case("sat")),
value(Weekday::Sat, tag_no_case("sam")),
value(Weekday::Sun, tag_no_case("sun")),
value(Weekday::Sun, tag_no_case("dim")),
)),
space0,
)(input)
}
/// The parse_simple_date function parses a single date from a given input string.
/// It supports different date formats:
/// * Day (Month)?
/// * (Month)? Day
/// * Day
///
/// ### Parsing Logic
/// The function uses the [nom::branch::alt] combinator to handle the different date formats.
/// Each format is represented by a separate [nom::combinator::map] combinator that extracts
/// the necessary date information and constructs the DatePoint object.
pub fn parse_simple_date(input: &str) -> IResult<&str, DatePoint> {
alt((
map(
tuple((space0, parse_month, space0, digit1, space0)),
|(_, month, _sep, day, _)| DatePoint::Date {
day: day.parse_to().unwrap(),
month: Some(month),
},
),
map(
tuple((space0, digit1, space0, parse_month, space0)),
|(_, day, _, month, _)| DatePoint::Date {
day: day.parse_to().unwrap(),
month: Some(month),
},
),
map(delimited(space0, digit1, space0), |day: &str| {
DatePoint::Date {
day: day.parse_to().unwrap(),
month: None,
}
}),
map(parse_weekday, DatePoint::Weekday),
))(input)
}
/// The parse_date_object function parses a single date object from a given input string.
/// It supports two formats:
/// * Date - Date
/// * Date
/// ### Parsing Logic
///
/// The function uses the [nom::branch::alt] combinator to handle the two date formats.
/// Each format is represented by a separate [nom::combinator::map] combinator that parses the date range or single date object.
/// ### Examples
/// ```
/// # use idlefox::date::date_parse::parse_date_object;
/// // Parse "20dec -31jan"
/// let result1 = parse_date_object("20dec -31jan").unwrap();
///
/// // Parse "Lun"
/// let result2 = parse_date_object("Lun").unwrap();
/// ```
pub fn parse_date_object(input: &str) -> IResult<&str, DateObject> {
alt((
map(
separated_pair(parse_simple_date, char('-'), parse_simple_date),
|(start, stop)| DateObject::Range(DateRange { start, stop }),
),
map(parse_simple_date, DateObject::Single),
))(input)
}
/// The parse_str_into_date function parses a list of date objects from a given input string.
/// Each date object is separated by a comma.
///
/// ### Parsing Logic
///
/// The function uses the [nom::multi::separated_list1] combinator to parse a list of date objects separated by commas.
/// Each date object is then parsed again using the [parse_date_object] function.
/// # Examples
/// ```
/// # use idlefox::date::parse_str_into_date;
/// // Parse "12 dec - 23 feb, lun - mer, 12, 14"
/// let list_dates = parse_str_into_date("12 dec - 23 feb, lun - mer, 12, 14").unwrap();
/// ```
pub fn parse_str_into_date(input: &str) -> IResult<&str, Vec<DateObject>> {
separated_list1(char(','), parse_date_object)(input)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parsing() {
let (leftover_input, output) = parse_month("jan €rré jan feb v").unwrap();
assert_eq!(leftover_input, " €rré jan feb v");
assert_eq!(output, Month::January);
let (leftover_input, output) =
parse_str_into_date(" 10 jan €rré10 jan 10 jan").unwrap();
assert_eq!(leftover_input, "€rré10 jan 10 jan");
let result = [DateObject::Single(DatePoint::Date {
day: 10,
month: Some(Month::January),
})];
test_dates(&output, &result);
let (leftover_input, output) = parse_str_into_date(" 10 jan 20").unwrap();
assert_eq!(leftover_input, "20");
let result = [DateObject::Single(DatePoint::Date {
day: 10,
month: Some(Month::January),
})];
test_dates(&output, &result);
let (leftover_input, output) = parse_str_into_date("feb 10 jan 20").unwrap();
assert_eq!(leftover_input, "jan 20");
let result = [DateObject::Single(DatePoint::Date {
day: 10,
month: Some(Month::February),
})];
test_dates(&output, &result);
let (leftover_input, output) =
parse_str_into_date(" 10 jan - 10 jan, tue , 23,mon-tue,").unwrap();
assert_eq!(leftover_input, ",");
let result = [
DateObject::Range(DateRange {
start: DatePoint::Date {
day: 10,
month: Some(Month::January),
},
stop: DatePoint::Date {
day: 10,
month: Some(Month::January),
},
}),
DateObject::Single(DatePoint::Weekday(Weekday::Tue)),
DateObject::Single(DatePoint::Date {
day: 23,
month: None,
}),
DateObject::Range(DateRange {
start: DatePoint::Weekday(Weekday::Mon),
stop: DatePoint::Weekday(Weekday::Tue),
}),
];
test_dates(&output, &result);
}
fn test_dates(output: &Vec<DateObject>, result: &[DateObject]) {
println!("{:?}", output);
for (a, b) in output.iter().zip(result.iter()) {
println!("Found: {:?}. Expected: {:?}", a, b);
assert_eq!(a, b);
}
}
}
// Procedural approach, in case all fails
// /// Parse all DatesObjects separated by commas
// fn parse_date_input(input: &str) -> Result<Vec<&str>, IdleError> {
// let (_, list_date) = separated_list0(char(','), complete::is_not(","))(input)?;
// // let find_ranges= list_date.iter().map(|date| separated_pair(, , )).collect();
// Ok(list_date)
// }
// // /// Parse all DatesObjects separated by commas
// fn parse_all_commas(input: &str) -> IResult<&str, Vec<&str>> {
// separated_list0(char(','), complete::is_not(","))(input)
// }

View File

@ -1,519 +0,0 @@
//! Utilities to handle date and relative date selection
use crate::{date::date_parse::parse_simple_date, error_handling::IdleError};
use chrono::{Datelike, Duration, Local, Month, Months, NaiveDate, Weekday};
use serde::{Deserialize, Serialize};
use super::{
date_parse::{DateObject, DatePoint},
parse_str_into_date,
};
/// Returns the date corresponding to the implicit Weekday
///
/// Aka the next day implied by the day given
/// If no context is given, the date is the same day next week from the current day
///
/// # Arguments
///
/// * `day`: The desired weekday.
/// * `context`: An optional date to use as a reference for calculating the relative day.
/// If not provided, the current date plus one week is used.
///
/// # Returns
///
/// A [NaiveDate] representing the calculated date based on the given weekday and context.
///
/// # Example
///
/// ```rust
/// # use chrono::{Weekday, Local};
/// # use idlefox::date::date_tools::relative_day_to_date;
/// let today = Local::now().date_naive();
/// // Get the date for next Monday relative to today
/// let monday = relative_day_to_date(Weekday::Mon, Some(today));
/// ```
pub fn relative_day_to_date(weekday: Weekday, context: Option<NaiveDate>) -> NaiveDate {
let context = context.unwrap_or(Local::now().date_naive()) + Duration::weeks(1);
let offset = context.weekday() as i64 - weekday as i64;
context - Duration::days(offset)
}
/// The relative_date_to_date function finds the date corresponding to a loosely defined implicit partial date.
///
/// The date returned will be the next valid date after the context.
///
/// ### Arguments
///
/// • date: The partial date to convert.
/// • context: An optional context date. If no context is given, the date will be inferred as the next valid date from now.
///
/// ### Returns
///
/// A [chrono::NaiveDate] representing the date corresponding to the given partial date in the context of the provided date.
///
/// ### Example
/// ```
/// # use chrono::NaiveDate;
/// # use idlefox::date::date_tools::relative_date_to_date;
/// // In this context we are trying to get the dates relative to the 14th of the month
/// let context_date = NaiveDate::from_ymd_opt(2023, 2, 14).unwrap();
/// // Get the next 16, relative to our context
/// let date = relative_date_to_date(16, None, Some(context_date)).unwrap();
/// assert_eq!(date, NaiveDate::from_ymd_opt(2023, 2, 16).unwrap()); // The next 16th in in february
/// // Get the next 1st, relative to our context
/// let date = relative_date_to_date(1, None, Some(context_date)).unwrap();
/// assert_eq!(date, NaiveDate::from_ymd_opt(2023, 3, 1).unwrap()); // The next 1st in in march, the next month
/// ```
pub fn relative_date_to_date(
day: u32,
month: Option<Month>,
context: Option<NaiveDate>,
) -> Result<NaiveDate, IdleError> {
let context = context.unwrap_or(Local::now().date_naive());
let mut new_dat = NaiveDate::from_ymd_opt(
context.year_ce().1 as i32,
match month {
Some(m) => m.number_from_month(),
None => context.month(),
},
day,
)
.ok_or(IdleError::InvalidDate(day, month))?;
if month.is_none() && day < context.day() {
new_dat = new_dat.checked_add_months(Months::new(1)).unwrap();
}
if new_dat.month() < context.month() {
new_dat = new_dat.checked_add_months(Months::new(12)).unwrap();
}
Ok(new_dat)
}
impl DatePoint {
/// Converts a DatePoint to a NaiveDate, optionally relative to a given context date.
///
/// The conversion depends on the specific type of [DatePoint]:
/// - For `DatePoint::Date { day, month }`, it calculates the next valid date after the provided or current context.
/// - For `DatePoint::Weekday(weekday)`, it finds the next occurrence of that weekday relative to the context.
///
/// # Arguments
///
/// * `self`: The [DatePoint] to convert.
/// * `context`: An optional reference date. If not provided, the function uses the current date as a default.
///
/// # Returns
///
/// A Result containing a [NaiveDate] if successful, or an [IdleError] if the date could not be calculated due to invalid input.
///
/// # Examples
///
/// ```
///use chrono::{Local, Month};
///use idlefox::date::date_parse::{DateObject, DatePoint};
///let today = Local::now().date_naive();
///let date_point = DatePoint::Date {
/// day: 14,
/// month: Some(Month::February),
///};
///let next_valid_date_object = DateObject::Single(date_point);
///let naive_date = next_valid_date_object
/// .to_naive_date_object(Some(today))
/// .unwrap();
/// ```
fn to_naive_date(self, context: Option<NaiveDate>) -> Result<NaiveDate, IdleError> {
match self {
DatePoint::Date { day, month } => relative_date_to_date(day, month, context),
DatePoint::Weekday(weekday) => Ok(relative_day_to_date(weekday, context)),
}
}
}
/// An enum representing either a single [NaiveDate] or a date range between two [NaiveDate].
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
// #[cfg_attr(test, derive(PartialEq))]
pub enum NaiveDateObject {
/// A range between two dates, inclusive at both ends.
Range {
/// Start of the range
start: NaiveDate,
/// End of the range
stop: NaiveDate,
},
/// A single [NaiveDate] object.
Single(NaiveDate),
}
/// A collection of [NaiveDateObject]s, allowing for sequential and random access to their start dates.
///
/// This struct provides an abstraction over a list of date objects, enabling both sequential iteration
/// over the dates in order or direct access to any date by its index. The structure is designed to handle
/// different sources of date information, allowing for flexible data manipulation based on the provided dates.
#[derive(Debug, Default, Serialize, Deserialize, Clone)]
#[cfg_attr(test, derive(PartialEq, Eq))]
pub struct NaiveDateList {
/// The inner vector
inner: Vec<NaiveDateObject>,
/// The leftover, unparsed string
unparsed: Option<String>,
}
impl DateObject {
/// Converts this [DateObject] to a corresponding [NaiveDateObject], using the provided context for relative date calculations.
///
/// # Examples
///
/// ```
/// # use idlefox::date::date_parse::{DateObject, DatePoint};
/// # use chrono::{Local, Month};
/// let today = Local::now().date_naive();
/// let date_point = DatePoint::Date {
/// day: 14,
/// month: Some(Month::March),
/// }; // February 14
/// let next_valid_date_object = DateObject::Single(date_point);
/// let naive_date = next_valid_date_object
/// .to_naive_date_object(Some(today))
/// .unwrap();
/// ```
pub fn to_naive_date_object(
&self,
context: Option<NaiveDate>,
) -> Result<NaiveDateObject, IdleError> {
match self {
DateObject::Range(date_range) => {
// This shenenigan is important otherwise very long ranges can overlap and become negative making no sense
let start = date_range.start.to_naive_date(context)?;
Ok(NaiveDateObject::Range {
start,
stop: date_range.stop.to_naive_date(Some(start))?,
})
}
DateObject::Single(date_point) => {
Ok(NaiveDateObject::Single(date_point.to_naive_date(context)?))
}
}
}
}
impl NaiveDateList {
/// Creates a new [NaiveDateList] from an existing vector of [NaiveDateObject]s.
pub fn new(inner: Vec<NaiveDateObject>, unparsed: Option<&str>) -> Self {
Self {
inner,
unparsed: unparsed.map(|v| v.to_string()),
}
}
/// Returns the number of dates in this [NaiveDateList].
pub fn len(&self) -> usize {
self.inner.len()
}
/// Checks if this [NaiveDateList] is empty.
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
/// Retrieves a reference to the [NaiveDateObject] at the specified index.
pub fn get(&self, index: usize) -> Option<&NaiveDateObject> {
self.inner.get(index)
}
/// Creates a new [NaiveDateList] from an existing vector of [DateObject]s and a context date.
///
/// The `context` is used to resolve any relative dates in the `inner` list.
///
/// # Examples
///
/// ```
/// # use chrono::Local;
/// # use idlefox::date::{
/// # date_parse::{DateObject, DatePoint},
/// # date_tools::NaiveDateList,
/// # };
/// let today = Local::now().date_naive();
/// let date_point = DatePoint::Date {
/// day: 14,
/// month: Some(chrono::Month::January),
/// };
/// let next_valid_date_object = DateObject::Single(date_point);
/// let list = NaiveDateList::from_context(vec![next_valid_date_object], Some(today), None);
/// assert!(list.is_ok());
/// ```
pub fn from_context(
inner: Vec<DateObject>,
context: Option<NaiveDate>,
unparsed: Option<&str>,
) -> Result<Self, IdleError> {
let mut new = Vec::new();
for elem in inner {
new.push(elem.to_naive_date_object(context)?);
}
Ok(Self {
inner: new,
unparsed: unparsed.map(|v| v.to_owned()),
})
}
}
// // TODO: If needed, make an iterator over all dates that this list of date encompasses
// impl IntoIterator for NaiveDateList {
// type Item = NaiveDateObject;
// type IntoIter = std::vec::IntoIter<Self::Item>;
// fn into_iter(self) -> Self::IntoIter {
// self.inner.into_iter()
// }
// }
/// This function parses a given input string representing date information and returns a `NaiveDateList`,
/// which is a collection of sequential or random accessible date objects. If there are any unparsed parts
/// left after processing the input, they can be retrieved using the `unparsed` method on the returned `Result`.
///
/// The function uses the context provided to resolve any relative dates within the input string.
///
/// # Arguments
///
/// * `input` - A string slice containing the date information to be parsed. This string may include various date formats,
/// single or range of dates, and possibly unparsed text.
/// * `context` - An optional NaiveDate that provides a context for resolving relative dates within the input. If no context
/// is provided, the function will attempt to use today's date as a fallback.
///
/// # Returns
///
/// A Result containing a `NaiveDateList` on success or an `IdleError` if parsing fails. The `Result` also includes any
/// unparsed text that was left over after processing the input string.
///
/// # Examples
///
/// ```
/// # use idlefox::date::parse_date_list;
/// # use chrono::NaiveDate;
/// let input = "Oct 5, Nov 15 - 18, sat, mon , tue-fry and some other text";
/// let context = NaiveDate::from_ymd_opt(2023, 10, 1);
/// let result = parse_date_list(input, context);
/// assert!(result.is_ok());
/// match result {
/// Ok(date_list) => println!("Parsed dates: {}", date_list.len()),
/// Err(e) => eprintln!("Error parsing dates: {}", e),
/// }
/// ```
pub fn parse_date_list(
input: &str,
context: Option<NaiveDate>,
) -> Result<NaiveDateList, IdleError> {
let (leftover, objects) = match parse_str_into_date(input)? {
("", objects) => (None, objects),
(leftover, objects) => (Some(leftover), objects),
};
NaiveDateList::from_context(objects, context, leftover)
}
/// This function parses a given input string representing a single date and returns a `NaiveDate`.
/// The function uses the context provided to resolve any relative dates within the input string.
///
/// # Arguments
/// * `input` - A string slice containing the date information to be parsed. This string may include various date formats,
/// and possibly unparsed text.
/// * `context` - An optional NaiveDate that provides a context for resolving relative dates within the input. If no context
/// is provided, the function will attempt to use today's date as a fallback.
///
/// # Returns
/// A Result containing a `NaiveDate` on success or an `IdleError` if parsing fails.
pub fn parse_single_date(input: &str, context: Option<NaiveDate>) -> Result<NaiveDate, IdleError> {
// As we simply ignore the leftover, we can directly call the to_naive_date method
parse_simple_date(input)?.1.to_naive_date(context)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::date::date_parse::DateRange;
#[test]
fn test_relative_days() {
let date = NaiveDate::from_ymd_opt(2024, 10, 30);
let date_next_mon = NaiveDate::from_ymd_opt(2024, 11, 4);
let date_next_tue = NaiveDate::from_ymd_opt(2024, 11, 7);
let date2 = NaiveDate::from_ymd_opt(2024, 12, 30);
let date2_next_sat = NaiveDate::from_ymd_opt(2025, 1, 11);
let date3 = NaiveDate::from_ymd_opt(2025, 1, 16);
let date3_next_sat = NaiveDate::from_ymd_opt(2025, 1, 26);
assert_eq!(
relative_day_to_date(Weekday::Mon, date),
date_next_mon.unwrap()
);
assert_eq!(
relative_day_to_date(Weekday::Thu, date),
date_next_tue.unwrap()
);
assert_eq!(
relative_day_to_date(Weekday::Sat, date2),
date2_next_sat.unwrap()
);
assert_eq!(
relative_day_to_date(Weekday::Sun, date3),
date3_next_sat.unwrap()
);
}
#[test]
fn test_relative_date() {
let context = Some(NaiveDate::from_ymd_opt(2024, 11, 10).unwrap());
assert_eq!(
relative_date_to_date(16, Some(Month::December), context).unwrap(),
NaiveDate::from_ymd_opt(2024, 12, 16).unwrap()
);
assert_eq!(
relative_date_to_date(7, Some(Month::January), context).unwrap(),
NaiveDate::from_ymd_opt(2025, 1, 7).unwrap()
);
assert_eq!(
relative_date_to_date(17, None, context).unwrap(),
NaiveDate::from_ymd_opt(2024, 11, 17).unwrap()
);
assert_eq!(
relative_date_to_date(5, None, context).unwrap(),
NaiveDate::from_ymd_opt(2024, 12, 5).unwrap()
);
assert!(relative_date_to_date(52, None, None).is_err());
// TODO: Do we consider this to be normal behaviour ?
assert!(relative_date_to_date(
31,
Some(Month::February),
NaiveDate::from_ymd_opt(2020, 1, 30)
)
.is_err());
assert_eq!(
relative_date_to_date(
12,
Some(Month::February),
NaiveDate::from_ymd_opt(2020, 1, 30)
)
.unwrap(),
NaiveDate::from_ymd_opt(2020, 2, 12).unwrap()
);
}
#[test]
fn test_impl_date() {
let context = Some(NaiveDate::from_ymd_opt(2024, 11, 10).unwrap());
assert_eq!(
DatePoint::Weekday(Weekday::Mon)
.to_naive_date(context)
.unwrap(),
NaiveDate::from_ymd_opt(2024, 11, 11).unwrap()
);
assert_eq!(
DatePoint::Date {
day: 10,
month: Some(Month::January)
}
.to_naive_date(context)
.unwrap(),
NaiveDate::from_ymd_opt(2025, 1, 10).unwrap()
);
}
#[test]
fn test_impl_dateobj() {
let context = Some(NaiveDate::from_ymd_opt(2024, 11, 10).unwrap());
let date_a = DatePoint::Date {
day: 10,
month: Some(Month::January),
};
let date_b = DatePoint::Date {
day: 21,
month: Some(Month::December),
};
assert_eq!(
DateObject::Single(date_a)
.to_naive_date_object(context)
.unwrap(),
NaiveDateObject::Single(NaiveDate::from_ymd_opt(2025, 1, 10).unwrap())
);
let date_obj = DateObject::Range(DateRange {
start: date_a,
stop: date_b,
})
.to_naive_date_object(context)
.unwrap();
assert_eq!(
date_obj,
NaiveDateObject::Range {
start: NaiveDate::from_ymd_opt(2025, 1, 10).unwrap(),
stop: NaiveDate::from_ymd_opt(2025, 12, 21).unwrap()
}
);
let vec_obj = NaiveDateList::new(vec![date_obj.clone()], None);
assert_eq!(vec_obj.len(), 1);
assert!(!vec_obj.is_empty());
assert_eq!(vec_obj.get(0).unwrap(), &date_obj);
assert!(!NaiveDateList::from_context(
vec![DateObject::Single(date_a), DateObject::Single(date_a)],
context,
None,
)
.unwrap()
.is_empty());
assert!(NaiveDateList::from_context(
vec![
DateObject::Single(DatePoint::Date {
day: 32,
month: None
}),
DateObject::Single(date_a)
],
context,
None,
)
.is_err());
}
#[test]
fn test_date_list() {
use chrono::NaiveDate;
let input = "Oct 5, Nov 15 - 18, sat, mon , tue-fri and some other text";
let context = NaiveDate::from_ymd_opt(2023, 10, 1);
let list = parse_date_list(input, context).unwrap();
assert_eq!(list.unparsed, Some("and some other text".to_string()));
assert_eq!(list.len(), 5);
let input = "Oct 5, Nov 15";
let list = parse_date_list(input, None).unwrap();
assert_eq!(list.unparsed, None);
assert_eq!(list.len(), 2);
}
#[test]
fn test_serialisation() {
let input = "Oct 5, Nov 15 - 18, sat, mon , tue-fri and some other text";
let context = NaiveDate::from_ymd_opt(2023, 10, 1);
let list = parse_date_list(input, context).unwrap();
let s = ron::to_string(&list).unwrap();
// Simple roundtrip assertion
assert_eq!(list, ron::from_str(&s).unwrap());
}
#[test]
fn test_parse_single() {
let cx = NaiveDate::from_ymd_opt(2023, 2, 12);
let tv = vec![
("ven", cx, NaiveDate::from_ymd_opt(2023, 2, 17).unwrap()),
("11", cx, NaiveDate::from_ymd_opt(2023, 3, 11).unwrap()),
("22", cx, NaiveDate::from_ymd_opt(2023, 2, 22).unwrap()),
("dec 30", cx, NaiveDate::from_ymd_opt(2023, 12, 30).unwrap()),
];
for (input, context, res) in tv {
println!("{:?} ({:?}) => {:?}", input, Some(context), res);
assert_eq!(parse_single_date(input, context).unwrap(), res);
}
}
}

View File

@ -1,65 +0,0 @@
//! The `date` module provides functionality to parse dates from strings and perform operations on dates.
//!
//! It consists of two submodules:
//!
//! - `dateparse`: This submodule is responsible for parsing a string representation of a date into a vector of [date_parse::DateObject] instances.
//! It utilizes in house representation of date as they are without context and therefore dont represent a real date yet.
//!
//! - `date_tools`: This submodule offers utility functions for working with dates.
//! It's main goal is do give a context for a subjective and incomplete date to transform it into a [chrono::NaiveDate] type from the chrono crate.
//!
//! # Functions
//!
//! The following functions are re-exported from the `date_tools` submodule:
//!
//! - [parse_date_list]: This function parses a given input string representing date information and returns a `NaiveDateList`,
//! which is a collection of sequential or random accessible date objects. If there are any unparsed parts
//! left after processing the input, they can be retrieved using the `unparsed` method on the returned `Result`.
//! The function uses the context provided to resolve any relative dates within the input string.
//!
//! - [parse_single_date]: This function parses a given input string representing a single date and returns a `NaiveDate`.
//! If there are any unparsed parts left after processing the input, they can be retrieved using the `unparsed` method on the returned `Result`.
//! The function uses the context provided to resolve any relative dates within the input string.
//!
//! # Examples
//!
//! ```
//! # use idlefox::date::parse_date_list;
//! # use chrono::NaiveDate;
//! let input = "Oct 5, Nov 15 - 18, sat, mon , tue-fry and some other text";
//! let context = NaiveDate::from_ymd_opt(2023, 10, 1);
//! let result = parse_date_list(input, context);
//! assert!(result.is_ok());
//! match result {
//! Ok(date_list) => println!("Parsed dates: {}", date_list.len()),
//! Err(e) => eprintln!("Error parsing dates: {}", e),
//! }
//! ```
#![allow(dead_code)]
// All structures
/// A punctual day (just one date)
pub struct DateEventPunctual {}
/// An interval
pub struct DateEventInterval {}
/// A date, wether punctual or interval
pub struct DateEventDate {}
/// A series of dates or intervals
pub struct DateEvent {}
// Defines date routines
pub mod date_parse;
pub mod date_tools;
// Republishing important functions
pub use date_parse::parse_str_into_date;
pub use date_tools::parse_date_list;
pub use date_tools::parse_single_date;
pub use date_tools::NaiveDateList;
pub use date_tools::NaiveDateObject;
// pub use date_tools::naivelistfromstr;
// pub use date_tools::naivedayfromstr;

View File

@ -1,147 +0,0 @@
//! This module provides a set of error types that can be used to handle various issues
//! with interacting with the Discord API or handling date-related tasks.
//!
//! The errors in this module are designed to provide detailed information about what
//! went wrong, making it easier to diagnose and fix problems.
#![allow(dead_code)]
use chrono::Month;
use log::SetLoggerError;
use poise::serenity_prelude;
use thiserror::Error;
use crate::ids::EventIdType;
/// Global error struct for idlefox
///
/// This enum represents various errors that can occur when interacting with most of the section of the program
#[derive(Error, Debug)]
pub enum IdleError {
/// Error indicating a critical failure in the Discord API interaction
///
/// This error is raised when an unrecoverable issue occurs while interfacing with the Discord API.
/// It may be recoverable by retrying the request or seeking assistance from the API provider.
#[error("An unrecoverable error occurred during Discord API interaction")]
GenericApiFailure,
/// Error indicating an invalid date format or an invalid date (dec 32, feb 30, etc..)
///
/// This error is raised when a user-provided date string cannot be parsed into a valid (date, month).
#[error("An error happened while tring to make sense of the date ({0:?},{1:?})")]
InvalidDate(u32, Option<Month>),
/// Generic error indicating an unexpected issue during Discord API call processing
///
/// This error is raised when an unforeseen issue occurs while handling a Discord API request.
/// It may be recoverable by re-trying the request or seeking assistance from the API provider.
#[error("An unexpected error occurred during Discord API processing: {0}")]
ApiProcessingError(#[from] serenity_prelude::Error),
/// Error indicating an invalid date string
///
/// This error is raised when a user-provided date string cannot be parsed into a valid [crate::date::date_parse::DatePoint].
/// Notifying the user and asking for manual correction will likely be required
#[error("An error occured while parsing the date given {0:?}")]
InvalidDateParsing(nom::Err<nom::error::Error<Box<str>>>),
/// Error indicating an issue with logging initialization
///
/// This error is raised when a critical issue occurs during logging initialization.
/// It may indicate that the file reader is read-only, and manual intervention will be required to resolve the problem.
#[error("An error occurred while initializing the logger: {0}")]
LoggerInitFailure(#[from] SetLoggerError),
/// Indicates an event couldn't be launched
///
/// Raised when there's an issue launching an event usually indicates something went wrong with bookeeping.
/// Note that while a HUID is given, it may no longer exist in memory and might only be found in logs.
#[error("An event couldn't be launched (Id: {0})")]
EventLaunch(EventIdType),
/// Error indicating multiple events couldn't be pruned
///
/// Raised when one or more events cannot be removed from the ongoing events list.
/// This usually indicates a problem with managing and updating the list of ongoing events.
/// Note that while a HUID is given, it may no longer exist in memory and might only be found in logs.
#[error("One or more events couldn't be removed from the ongoing events list (Id(s): {0:?})")]
EventPrune(Vec<EventIdType>),
/// Error indicating an event could not be deleted
///
/// This error is raised when attempting to delete an event fails,
/// either due to a problem with bookkeping or because the specified HUID
/// does not correspond to any existing events anymore.
#[error("An event couldn't be deleted (Id: {0})")]
DeleteEvent(EventIdType),
/// Error indicating that an ongoing event launch couldn't be performed
///
/// This error was likely raised as a launch operation for an event was already underway.
/// Launching multiple times for the same event may lead to inconsistent states or data corruption.
#[error("Couldn't launch event (Id: {0})")]
LaunchingEvent(EventIdType),
/// Error indicating a mutex was poisoned or couldn't be acquired
///
/// 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 trying 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 trying to acquire discord guilds")]
AcquiringDiscordGuild,
/// Indicates an error occuring while trying to convert from a DiscordContainer into a ParsedVote
///
/// This error will happen when an incorrect string is sent to a command invocation
#[error("An error occured while trying to parse a Discord command")]
DiscordContainerParse,
/// Indicate a backup write couldn't be done, usually means the file descriptor is busy or permission are incorrect
#[error("An error occured while trying to write file {0} {1}")]
BackupWriteError(String, std::io::Error),
/// Indicate a backup read couldn't be done, usually means the file descriptor is busy or permission are incorrect
#[error("An error occured while trying to read file {0} {1}")]
BackupReadError(String, std::io::Error),
/// Indicate a value couldn't be serialized
#[error("An error occured while trying to serialize data {0}")]
SerdeError(serde_json::Error),
/// Indlcate the config couldn't be loaded properly
#[error("An error occured while trying to load the config {0}")]
LoadingConfig(std::io::Error),
/// Indlcate the config couldn't be saved properly
#[error("An error occured while trying to save the config {0}")]
SavingConfig(std::io::Error),
}
impl From<nom::Err<nom::error::Error<&str>>> for IdleError {
fn from(err: nom::Err<nom::error::Error<&str>>) -> Self {
Self::InvalidDateParsing(err.map_input(|input| input.into()))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn into_error() -> Result<(), IdleError> {
Err(nom::Err::Error(nom::error::Error::new(
"",
nom::error::ErrorKind::Tag,
)))?
}
#[test]
fn test_nom_error() {
match into_error() {
Err(IdleError::InvalidDateParsing(_d)) => {}
_ => panic!("The convertion from a nom error into a IdleError failed"),
};
}
}

View File

@ -1,67 +0,0 @@
//! This module contains utilities for generating event ids.
//!
//! Features:
//! Generating a human readable ID for a HUID
//! Finding the HUID from an ID
//! Removing ID as needed
use crate::votes::EventHolder;
/// Generic type representing an ID
pub type EventIdType = String;
/// Generate an id
///
/// # Examples
///
/// ```
/// use idlefox::ids::generate_id;
/// let id: String = generate_id();
/// println!("Generated id: {}", id);
/// ```
pub fn generate_id() -> String {
human_ids::generate(None)
}
/// Generate a unique id, slower in timing but insure zero collision at runtime
///
/// # Examples
///
/// ```
/// use idlefox::ids::generate_unique_id;
/// # use idlefox::votes::EventHolder;
/// let holder = EventHolder::default();
/// let id: String = generate_unique_id(&holder);
/// println!("Generated id: {}", id);
pub fn generate_unique_id(holder: &EventHolder) -> String {
let id = generate_id();
match holder.contains_event(&id) {
// Testing this collision is not possible
#[cfg(not(tarpaulin_include))]
true => generate_unique_id(holder),
false => id,
}
}
#[cfg(test)]
mod test {
use crate::votes::{add_pending_event, EventHolder, EventPending};
use super::{generate_id, generate_unique_id};
#[test]
fn test_id_generation() {
let id = generate_id();
assert!(!id.is_empty())
}
#[test]
fn test_id_unique() {
let holder = EventHolder::default();
add_pending_event(EventPending::default(), &holder).unwrap();
let id = generate_unique_id(&holder);
assert!(!id.is_empty());
}
}

437
src/io.rs
View File

@ -1,437 +1,10 @@
//! Functions to handle I/O operations with Discord.
//! All IO related functions, include all Discord IO functions
//!
//! 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<dyn std::error::Error + Send + Sync>;
/// 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<serenity::RoleId>,
/// Optional hours describing the specific date of the event
pub(crate) hours: Option<String>,
/// Auto-Start date of the event (in human-readable format)
pub(crate) start_date: Option<String>,
/// Days not selected for the vote
pub(crate) non_days: Option<String>,
/// Days selected for the vote
pub(crate) days: Option<String>,
/// Date the event begins
pub(crate) date_begin: Option<String>,
/// Date the event ends
pub(crate) date_end: Option<String>,
/// 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<String>,
/// 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<String>,
/// Days for which reactions should "not count"
#[name = "Jours non dispos"]
#[placeholder = "'lun', '30', '2 dec'"]
non_days: Option<String>,
// 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<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()),
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 `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<String>` 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<String> {
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<serenity::RoleId>,
#[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,
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<serenity::RoleId>,
#[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> {
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<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();
}
//! Features:
//! All recv and send functions to discord
//! Helper function for advanced checks
#[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,
);
}
// use super::*;
}

View File

@ -1,28 +0,0 @@
//! This is the root module of the `idlefox` library.
//!
//! It includes modules related to configuration, date parsing and handling, input/output operations, persistence management,
//! server-side operations, voting mechanisms, and process watchdog functionality. Each module provides functionalities for
//! managing different aspects of idle processes, such as reading from/write to files, storing data persistently,
//! running servers, receiving votes, monitoring process status, and more.
//!
//! 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
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 votes; // Likely in lib
mod watchdog; // Definitely in lib
// // Re export
// pub use votes::add_future_event;
// pub use votes::launch_future_event;
pub use error_handling::IdleError;
pub use watchdog::main_scheduler_loop;

View File

@ -5,25 +5,14 @@
// This line is here to force the use of extensive documentation
#![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;
mod io;
mod modules;
mod persistence;
mod server;
mod votes;
mod watchdog;
// The main loop is untestable
#[cfg(not(tarpaulin_include))]
#[tokio::main]
async fn main() {
use idlefox::votes::EventHolder;
use tokio::task;
// TODO: Actually load them from disk
let event_context = EventHolder::default();
init_logger().unwrap();
// TODO: Check that this is actually what we want
task::spawn(main_scheduler_loop(
time::interval(time::Duration::from_secs(5)),
event_context.clone(),
));
discord_main_loop(event_context).await;
fn main() {
println!("Hello, world!");
}

View File

@ -5,59 +5,6 @@
//! 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::*;

View File

@ -6,105 +6,7 @@
//!
//!
use crate::IdleError;
use serde::{de::DeserializeOwned, Serialize};
use std::io::{Read, Write};
/// Tries to load the list of pending events from disk or return a default (empty) list
pub(crate) fn load_from_reader<Data, Reader>(rdr: Reader) -> Data
where
Data: Default + DeserializeOwned,
Reader: Read + Sized,
{
serde_json::from_reader(rdr).unwrap_or_default()
}
/// Load a struct into an Arc Mutex, mapping errors into BackupError
///
/// This macro is direct sugarcoating of the load_from_disk macro
#[macro_export]
macro_rules! load_from_reader {
($r_type:ident, $path:expr) => {
Arc::new(std::sync::Mutex::new(load_from_reader::<$r_type, File>(
File::open($path).map_err(|e| IdleError::BackupReadError($path.to_owned(), e))?,
)))
};
}
// Testing a bad serialisation is pointless
#[cfg(not(tarpaulin_include))]
/// Tries to save the list to disk and return an error on failure
pub(crate) fn save_to_writer<Data, Writer>(data: Data, mut writer: Writer) -> Result<(), IdleError>
where
Data: Serialize,
Writer: Write + Sized + std::fmt::Debug,
{
writer
.write(
serde_json::to_string_pretty(&data)
.map_err(IdleError::SerdeError)?
.as_bytes(),
)
.map_err(|e| IdleError::BackupWriteError(format!("{:?}", writer), e))?;
Ok(())
}
/// Save a struct behind an Arc Mutex into a file, mapping errors into BackupError
///
/// This macro is direct sugarcoating of the save_to_writer function
///
/// # Usage
///
/// save_it!()
#[macro_export]
macro_rules! save_to_writer {
($value:expr, $r_type:ident, $path:expr) => {
save_to_writer::<&$r_type, File>(
&$value.lock().unwrap(),
File::create($path).map_err(|e| IdleError::BackupWriteError($path.to_string(), e))?,
)?;
};
}
#[cfg(test)]
mod tests {
use super::*;
use crate::votes::{EventPending, ListOngoingEvents, ListPendingEvents};
use std::fs::{create_dir, remove_dir_all, File};
use std::io::BufWriter;
use std::sync::{Arc, Mutex};
#[test]
fn test_serialisation() {
let event_og = ListOngoingEvents::default();
let mut buffer = BufWriter::new(Vec::new());
let serialisation = save_to_writer(&event_og, &mut buffer);
assert!(serialisation.is_ok());
let deserialized_data: ListOngoingEvents = load_from_reader(buffer.buffer());
assert_eq!(event_og, deserialized_data);
}
#[test]
fn test_macro_caller() {
test_macros().unwrap()
}
fn test_macros() -> Result<(), IdleError> {
let event_og = Arc::new(Mutex::new(ListPendingEvents::default()));
{
let mut e = event_og.lock().unwrap();
for _ in 0..10 {
e.add_pending_event(EventPending::default())?;
}
}
let _ = remove_dir_all("test");
let _ = create_dir("test");
save_to_writer!(&event_og, ListPendingEvents, "test/testwrite.json");
let event_new = load_from_reader!(ListPendingEvents, "test/testwrite.json");
assert_eq!(
event_og.lock().unwrap().to_owned(),
event_new.lock().unwrap().to_owned()
);
Ok(())
}
// use super::*;
}

View File

@ -4,10 +4,6 @@
//! Show all votes (pending and happening)
//! Allow vote closing
//!
// warp for creating the API
// Tokio to run an asynchronous server
// Serde to help serialize incoming JSON
// parking_lot to create a ReadWriteLock for your local storage
#[cfg(test)]
mod tests {

14
src/votes.rs Normal file
View File

@ -0,0 +1,14 @@
//! Handles all votes related logic
//!
//! Features:
//! Structs & Traits
//! Votes (struct)
//! Event (struct)
//! ListCurrentEvents (struct)
//! ListFutureEvents (struct)
//!
#[cfg(test)]
mod tests {
// use super::*;
}

View File

@ -1,22 +0,0 @@
//! The ballot submodule provides functionality for managing user ballots, which include casting votes towards events.
//!
//! # Important Structures
//!
//! * `Ballot`: Represents a single vote cast by a user towards an event. It includes fields for the event ID, user handle,
//! and the value or option voted for.
use serde::{Deserialize, Serialize};
use super::{BallotValueType, EventIdType, UserDataType};
/// A `Ballot` represents a user interaction towards an event. This struct is used to record the details of a vote,
/// including which user casted it, which event it pertains to, and what value or option was voted for.
#[derive(Serialize, Deserialize, Debug, Clone)]
#[cfg_attr(test, derive(Eq, PartialEq))]
pub struct Ballot {
/// The event the vote refers to
linked_event: EventIdType,
/// The user casting the vote
user_handle: UserDataType,
/// What the user voted for
vote_value: BallotValueType,
}

View File

@ -1,204 +0,0 @@
//! The `voting_events` submodule is dedicated to managing the lifecycle and
//! functionality of voting events
//!
//! * `ParsedVote`: A comprehensive structure that represents a single vote,
//! encapsulating both ongoing and planned votes. It stores information
//! about the event's title, description, status, start and end dates,
//! auto-delete date, votes cast by users, list of valid options (candidates)
//! for the vote, and type of vote being conducted.
//! * `EventStatus`: An enumeration that defines various states a voting event
//! can be in, such as planned, ongoing, closed, and cancelled. This helps
//! to track and manage the progression of each voting event according to
//! predefined rules and conditions.
#![allow(dead_code)]
use std::fmt::Display;
use chrono::{Days, Local, NaiveDate, NaiveDateTime, NaiveTime};
use serde::{Deserialize, Serialize};
use crate::{
date::{parse_date_list, parse_single_date, NaiveDateList},
io::{VoteContainer, VoteTypeIdentifier},
IdleError,
};
use super::Ballot;
/// A pending event, waiting to be opened. In this state the even can be safely modified
/// and either manual input or the autostart date will start the vote.
#[derive(Serialize, Deserialize, Default, Clone)]
#[cfg_attr(test, derive(Debug, PartialEq, Eq))]
pub struct EventPending {
/// The parsed representation of the vote associated with this event.
/// It holds the details required for the voting process.
pub(super) parsed_vote: ParsedVote,
}
impl EventPending {
pub fn into_ongoing(self) -> EventOngoing {
EventOngoing {
parsed_vote: self.parsed_vote,
}
}
}
#[derive(Serialize, Deserialize, Clone)]
#[cfg_attr(test, derive(Debug, PartialEq))]
// An ongoing event, waiting to be closed thus allowing the ballots to be counted.
pub struct EventOngoing {
/// The parsed representation of the vote associated with this event.
/// It holds the details required for the voting process.
pub(super) parsed_vote: ParsedVote,
}
impl Display for EventOngoing {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
self.parsed_vote.fmt(f)
}
}
impl EventOngoing {
pub fn into_closed(self) -> EventClosed {
EventClosed {
parsed_vote: self.parsed_vote,
}
}
}
#[derive(Serialize, Deserialize, Clone)]
// #[cfg_attr(test, derive(Clone))]
/// A closed event, while the users cannot interract with it in this state,
/// this event can still be reopened and it's results can be read.
/// All events have an expiry date and in this state the event will be cleaned
/// up after a while.
///
/// Closing an event will call the cleanup and completion functions.
pub struct EventClosed {
/// The parsed representation of the vote associated with this event.
/// It holds the details required for the voting process.
pub(super) parsed_vote: ParsedVote,
}
/// A `ParsedVote` represents a voting event that has been parsed and validated. It
/// contains all necessary information about the voting process itself.
///
/// This structure is specifically used within the application to encapsulate both
/// ongoing and planned voting events, providing a clear and organized way to manage their
/// data throughout their lifecycle.
#[derive(Debug, Serialize, Deserialize, Default, Clone)]
#[cfg_attr(test, derive(Eq, PartialEq))]
pub(super) struct ParsedVote {
/// The title of the even
pub(super) title: String,
/// Description of the event
pub(super) description: String,
/// Date at which to autostart the vote process
pub(super) launch_date: NaiveDateTime,
/// Date at which to autoclose the vote process
pub(super) close_date: NaiveDateTime,
/// Date at which to autodelete the vote process
pub(super) auto_delete_date: NaiveDateTime,
/// The inner list of votes cast
pub(super) votes: Vec<Ballot>,
/// The list of values to vote for, this list all the valid dates to vote for
pub(super) list_candidates: NaiveDateList,
}
impl ParsedVote {
/// All the logic behind a vote becoming live
pub(super) fn launch(&mut self) -> Result<(), IdleError> {
// TODO: Define this
// self.status = EventStatus::Started;
// Maybe send a message ? the bot will need the Huid of the event to be able to add reaction
// TODO: This is a vkypoint, as this method will need an IO interaction
Ok(())
}
}
impl ParsedVote {
/// Try to parse a vote from a votecontainer
fn try_from_with_context(
value: VoteContainer,
context: Option<NaiveDate>,
vote_type: VoteTypeIdentifier,
) -> Result<Self, IdleError> {
let context = context.unwrap_or(Local::now().date_naive());
let close_date = parse_single_date(
&value.date_end.ok_or(IdleError::DiscordContainerParse)?,
Some(context),
)?
.and_time(NaiveTime::from_hms_opt(20, 00, 00).unwrap());
// TODO: Have a better auto_delete threshold
let auto_delete_date = close_date.checked_add_days(Days::new(12)).unwrap();
// TODO: Use this to have better date selection handling
match vote_type {
VoteTypeIdentifier::WeeklyVote => {
// Start is next week, end is end of week, days is all week
}
VoteTypeIdentifier::ShortVote => {
// Start is ?, end is ?, days must be given
}
VoteTypeIdentifier::LongVote => (),
VoteTypeIdentifier::Uninitialised => (),
}
Ok(Self {
title: value.title,
description: value.description,
// TODO: Have a logic to find a good start date
launch_date: parse_single_date(
&value.start_date.ok_or(IdleError::DiscordContainerParse)?,
Some(context),
)?
.and_time(NaiveTime::from_hms_opt(20, 00, 00).unwrap()),
close_date,
auto_delete_date,
votes: Vec::new(),
// TODO: How can days be empty ? Add the non_days.
list_candidates: parse_date_list(
&value.days.ok_or(IdleError::DiscordContainerParse)?,
Some(context),
)?,
})
}
}
impl Display for ParsedVote {
/// A display for a vote, it is exactly what the discord bot will send
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
// TODO: Complete this (vky)
write!(f, "{:?}", self)
}
}
#[cfg(test)]
mod test {
use super::{EventPending, ParsedVote};
use crate::io::{VoteContainer, VoteTypeIdentifier};
use chrono::NaiveDate;
#[test]
// TODO: Complete this test
fn test_display() {
let pv = ParsedVote::default();
let _ = format!("{}", pv);
let eo = EventPending::default().into_ongoing();
let _ = format!("{}", eo);
}
#[test]
#[ignore]
// TODO: Complete this test
fn test_conversion() {
let cx = NaiveDate::from_ymd_opt(2000, 12, 12);
let v = ParsedVote::try_from_with_context(
VoteContainer::default(),
cx,
VoteTypeIdentifier::WeeklyVote,
);
println!("{:?}", v);
assert!(v.is_ok());
}
}

View File

@ -1,332 +0,0 @@
//! Submodule including all helper functions to handle vote creation and evolution
//!
use crate::{config::GlobalConfig, votes::traits::BorrowInner};
use chrono::NaiveDate;
use std::{
fs::{create_dir, File},
sync::Arc,
};
use super::{
events::{EventOngoing, EventPending},
holders::{ListClosedEvents, TypedEvent},
ListOngoingEvents, ListPendingEvents,
};
use crate::{
ids::EventIdType,
load_from_reader,
persistence::{load_from_reader, save_to_writer},
save_to_writer, IdleError,
};
/// Adds a parsed vote to the list of planned events.
///
/// This function will use the `PendingEvents` instance to store the provided event.
/// The structure of the input parameter `event` is expected to be a correctly formatted parsed vote.
///
/// ## Parameters:
/// - `event`: A `ParsedVote` struct representing the details of the event to be scheduled.
///
/// ## Example:
/// ```rust
/// use idlefox::votes::{add_pending_event, EventHolder, EventPending};
/// let ev_ctx = EventHolder::default();
/// let parsed_vote = EventPending::default();
/// let id = add_pending_event(parsed_vote, &ev_ctx).unwrap();
/// ```
pub fn add_pending_event(
event: EventPending,
ev_ctx: &EventHolder,
) -> Result<EventIdType, IdleError> {
ev_ctx
.pending_events
.lock()
.unwrap()
.add_pending_event(event)
}
/// Launches a pending event by transferring it from the pending to ongoing events list.
///
/// This function identifies an event by its HUID and moves it from the planned
/// (pending) events to the ongoing events. If the event is successfully launched, it returns `Ok(())`.
/// Otherwise, it returns an error of type `IdleError`.
///
/// ## Parameters:
/// - `Huid`: A `Huid` that uniquely identifies the event to be launched.
///
/// ## Example:
/// ```rust
/// use idlefox::votes::{add_pending_event, make_into_ongoing_event, EventPending, EventHolder};
/// let ev_ctx = EventHolder::default();
/// let id = add_pending_event(EventPending::default(), &ev_ctx).unwrap();
///
/// make_into_ongoing_event(&id, &ev_ctx).unwrap()
/// ```
pub fn make_into_ongoing_event(huid: &EventIdType, ev_ctx: &EventHolder) -> Result<(), IdleError> {
ev_ctx.pending_events.lock().unwrap().launch(huid, ev_ctx)
}
/// Manually adds an ongoing event.
///
/// This function is intended for internal use and directly adds an event
/// to the list of ongoing events. It expects a HUID and a parsed vote as inputs,
/// using which it updates the `OngoingEvents` instance.
///
/// ## Parameters:
/// - `huid`: A `Huid` that uniquely identifies the event to be added.
/// - `event`: A `ParsedVote` struct representing the details of the ongoing event to be added.
///
/// ## Example:
/// ```rust
/// use idlefox::ids::generate_id;
/// use idlefox::votes::{add_ongoing_event, EventHolder, EventPending};
/// let ev_ctx = EventHolder::default();
/// let huid = generate_id(); // A new id
/// let ongoing = EventPending::default().into_ongoing(); // A very legit event
/// add_ongoing_event(&huid, ongoing, &ev_ctx).unwrap();
/// ```
pub fn add_ongoing_event(
huid: &EventIdType,
event: EventOngoing,
ev_ctx: &EventHolder,
) -> Result<(), IdleError> {
ev_ctx
.ongoing_events
.lock()
.unwrap()
.add_event(huid, event)?;
Ok(())
}
/// Destroy an event without closing it and officially ending it
///
/// This function removes an ongoing event from the list of ongoing events.
/// It expects a HUID as input and returns a `Result` containing either a `ParsedVote`
/// struct representing the details of the removed event or an `IdleError`.
///
/// ## Example:
/// ```rust
/// # use idlefox::votes::{
/// # add_pending_event, del_ongoing_event, make_into_ongoing_event, EventPending, EventHolder
/// # };
/// let ev_ctx = EventHolder::default();
/// let id = add_pending_event(EventPending::default(), &ev_ctx).unwrap();
/// make_into_ongoing_event(&id, &ev_ctx).unwrap();
///
/// del_ongoing_event(&id, &ev_ctx).unwrap();
/// ```
pub fn del_ongoing_event(
huid: &EventIdType,
ev_ctx: &EventHolder,
) -> Result<EventOngoing, IdleError> {
ev_ctx.ongoing_events.lock().unwrap().del_event(huid)
}
/// Destroy a pending event without closing it
///
/// This function removes a pending event from the list of pending events.
/// It expects a HUID as input and returns a `Result` containing either a `ParsedVote`
/// struct representing the details of the removed event or an `IdleError`.
///
/// ## Example:
/// ```rust
/// # use idlefox::votes::{
/// # add_pending_event, del_pending_event, make_into_ongoing_event, EventPending, EventHolder
/// # };
/// let ev_ctx = EventHolder::default();
/// let id = add_pending_event(EventPending::default(), &ev_ctx).unwrap();
/// del_pending_event(&id, &ev_ctx).unwrap();
/// ```
pub fn del_pending_event(
huid: &EventIdType,
ev_ctx: &EventHolder,
) -> Result<EventPending, IdleError> {
ev_ctx.pending_events.lock().unwrap().del_event(huid)
}
/// This function is used to close an ongoing event and return the parsed vote associated with it. If the closure is successful, the owned event is returned for post-treatment.
/// # Arguments
///
/// * `huid` - A Huid representing the identifier of the event that is to be closed.
///
/// ## Example:
/// ```rust
/// # use idlefox::votes::{
/// # add_pending_event, close_ongoing_event, make_into_ongoing_event, EventPending, EventHolder,
/// # };
/// let ev_ctx = EventHolder::default();
/// let id = add_pending_event(EventPending::default(), &ev_ctx).unwrap();
/// make_into_ongoing_event(&id, &ev_ctx).unwrap();
/// close_ongoing_event(&id, &ev_ctx).unwrap();
/// ```
pub fn close_ongoing_event(huid: &EventIdType, ev_ctx: &EventHolder) -> Result<(), IdleError> {
ev_ctx
.ongoing_events
.lock()
.unwrap()
.close_event(huid, ev_ctx)
}
/// A link to all events, to be shared between threads related to this event pool.
///
/// This struct serves as a central hub for managing and accessing different states of events within the
/// system. It provides access to pending, ongoing, and potentially closed events.
/// The use of `Arc<Mutex<>>` ensures that the events can be safely shared and modified across multiple
/// threads without running into race conditions or other concurrency issues.
#[derive(Clone, Default)]
pub struct EventHolder {
/// A reference-counted pointer to a mutex-protected `PendingEvents` instance, managing all pending events.
///
/// Pending events are those that have been scheduled but not yet started
pub pending_events: Arc<std::sync::Mutex<ListPendingEvents>>,
/// A reference-counted pointer to a mutex-protected `OngoingEvents` instance, managing all ongoing events.
///
/// Ongoing events are currently running but not yet closed.
pub ongoing_events: Arc<std::sync::Mutex<ListOngoingEvents>>,
/// A reference-counted pointer to a mutex-protected `OngoingEvents` instance, managing all closed events.
///
/// Closed events have been voted up but havent been deleted and can therefore be watched or opened again.
/// These events will be autodeleted after a while
pub closed_events: Arc<std::sync::Mutex<ListClosedEvents>>,
/// A reference-counted pointer to a mutex-protected `NaiveDate` instance, representing the last date the watchdog was updated.
pub old_date: Arc<std::sync::Mutex<NaiveDate>>,
/// The newly created discord context
pub discord_ctx: Arc<tokio::sync::Mutex<Option<poise::serenity_prelude::Context>>>,
/// A link to the active config
pub config: Arc<std::sync::RwLock<GlobalConfig>>,
}
/// Access the inner value by borrowing the inner wrapper
///
/// A macro is better than a trait and polymorphic code at this scale
macro_rules! inner {
($value:expr) => {
$value.lock().unwrap().borrow_inner()
};
}
impl EventHolder {
pub fn try_load_from_disk(save_path: Option<&str>) -> Result<Self, IdleError> {
let save_path = save_path.unwrap_or("data");
Ok(Self {
pending_events: load_from_reader!(
ListPendingEvents,
save_path.to_owned() + "/pending_events.json"
),
ongoing_events: load_from_reader!(
ListOngoingEvents,
save_path.to_owned() + "/ongoing_events.json"
),
closed_events: load_from_reader!(
ListClosedEvents,
save_path.to_owned() + "/closed_events.json"
),
old_date: load_from_reader!(NaiveDate, save_path.to_owned() + "/old_date.json"),
config: Arc::new(std::sync::RwLock::new(GlobalConfig::try_load_from_disk()?)),
..Default::default()
})
}
pub fn try_save_to_disk(&self, save_path: Option<&str>) -> Result<(), IdleError> {
let save_path = save_path.unwrap_or("data");
let _ = create_dir(save_path);
save_to_writer!(
self.pending_events,
ListPendingEvents,
save_path.to_owned() + "/pending_events.json"
);
save_to_writer!(
self.ongoing_events,
ListOngoingEvents,
save_path.to_owned() + "/ongoing_events.json"
);
save_to_writer!(
self.closed_events,
ListClosedEvents,
save_path.to_owned() + "/closed_events.json"
);
save_to_writer!(
&self.old_date,
NaiveDate,
save_path.to_owned() + "/old_date.json"
);
self.config.read().unwrap().try_save_to_disk()?;
Ok(())
}
/// Check wether the holder contains an event
///
/// This is a low level plumbing tool, mostly used to check for collisions
pub(crate) fn contains_event(&self, id: &String) -> bool {
inner!(self.pending_events).contains_key(id)
|| inner!(self.ongoing_events).contains_key(id)
|| inner!(self.closed_events).contains_key(id)
}
/// Try to find an even by it's id, returns a TypedEvent to keep track of the location of the event
///
/// Note that this function is useless right now as it clones the event making it very impractical
#[deprecated]
#[allow(dead_code)]
pub(crate) fn find_event(&self, id: &String) -> Option<TypedEvent> {
inner!(self.pending_events)
.get(id)
.map(|e| TypedEvent::Pending(e.clone()))
.or_else(|| {
inner!(self.ongoing_events)
.get(id)
.map(|e| TypedEvent::Ongoing(e.clone()))
})
.or_else(|| {
inner!(self.closed_events)
.get(id)
.map(|e| TypedEvent::Closed(e.clone()))
})
}
}
#[cfg(test)]
mod test {
use crate::votes::{holders::TypedEvent, EventPending};
use super::{add_pending_event, close_ongoing_event, make_into_ongoing_event, EventHolder};
#[test]
fn test_save_load() {
let hld = EventHolder::default();
let (a, b, c) = (
add_pending_event(EventPending::default(), &hld).unwrap(),
add_pending_event(EventPending::default(), &hld).unwrap(),
add_pending_event(EventPending::default(), &hld).unwrap(),
);
make_into_ongoing_event(&b, &hld).unwrap();
make_into_ongoing_event(&c, &hld).unwrap();
close_ongoing_event(&c, &hld).unwrap();
assert!(hld.contains_event(&a));
assert!(hld.contains_event(&b));
assert!(hld.contains_event(&c));
hld.try_save_to_disk(Some("bobito")).unwrap();
let hld2 = EventHolder::try_load_from_disk(Some("bobito")).unwrap();
assert!(hld2.contains_event(&a));
assert!(hld2.contains_event(&b));
assert!(hld2.contains_event(&c));
let (a2, b2, c2) = (
hld.find_event(&a).unwrap(),
hld.find_event(&b).unwrap(),
hld.find_event(&c).unwrap(),
);
// match (a2, b2, c2) {
// TypedEvent::Ongoing(),TypedEvent::Pending(),TypedEvent::Closed() => (),
// _ =>
// }
assert!(matches!(a2, TypedEvent::Pending(_)));
assert!(matches!(b2, TypedEvent::Ongoing(_)));
assert!(matches!(c2, TypedEvent::Closed(_)));
}
}

View File

@ -1,389 +0,0 @@
//! This module is responsible for managing events in an application. It includes
//! functionality to handle both pending and ongoing events, with support for categorizing
//! them based on their status.
//!
//! *Important Structures:*
//! - `PendingEvents`: Manages pending events
//! - `OngoingEvents`: Manages ongoing events
//! - `ClosedEvents`: Represents closed events (TODO: Implementation needed)
//!
//! Note:
//! The module aims to provide a robust framework for managing event lifecycles within an
//! application, ensuring separation between pending and ongoing events and supporting
//! actions such as adding, launching, processing, and autoclosing events.
use chrono::NaiveDateTime;
use serde::{Deserialize, Serialize};
use crate::{
ids::{generate_id, EventIdType},
IdleError,
};
use super::{
add_ongoing_event,
events::{EventClosed, EventOngoing, EventPending},
ClosedHashmap, EventHolder, OngoingHashmap, PendingHashmap,
};
/// 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)]
#[cfg_attr(test, derive(Debug, PartialEq, Clone))]
pub struct ListPendingEvents {
/// The list of pending events
pub(super) pending_events: PendingHashmap,
}
impl ListPendingEvents {
/// Add a new event to the list of upcoming events.
///
/// This function generates a new HUID for the event before adding it to the list.
pub fn add_pending_event(&mut self, event: EventPending) -> Result<EventIdType, IdleError> {
let id = generate_id();
self.pending_events.insert(id.clone(), event);
Ok(id)
}
/// Process and activate all upcoming events if the auto-launch time has been reached.
///
/// Returns an `IdleError` if there's an issue launching any event or adding it to the ongoing list.
pub fn process_upcoming(
&mut self,
current_time: NaiveDateTime,
ev_ctx: &EventHolder,
) -> Result<(), IdleError> {
self.find_upcoming(current_time)
.iter()
.try_for_each(|huid| {
self.launch(huid, ev_ctx)?;
Ok(())
})
}
/// Launch the specified event by moving it from pending events to ongoing events.
///
/// Returns an `IdleError` if the event cannot be found in pending events.
pub(super) fn launch(
&mut self,
huid: &EventIdType,
ev_ctx: &EventHolder,
) -> Result<(), IdleError> {
let event = self
.pending_events
.remove(huid)
.ok_or(IdleError::EventLaunch(huid.to_string()))?;
add_ongoing_event(huid, event.into_ongoing(), ev_ctx)?;
// make_into_ongoing_event(huid)?;
Ok(())
}
/// Find all events that are scheduled to start after the given date.
///
/// Returns a vector of HUIDs corresponding to the upcoming events.
/// TODO: Consider returning references
pub(super) fn find_upcoming(&self, current_time: NaiveDateTime) -> Vec<EventIdType> {
self.pending_events
.iter()
.filter(|&(_, e)| e.parsed_vote.launch_date <= current_time)
.map(|(k, _v)| (k.clone()))
.collect()
}
/// delete the event without launching it
pub fn del_event(&mut self, huid: &EventIdType) -> Result<EventPending, IdleError> {
self.pending_events
.remove(huid)
.ok_or(IdleError::DeleteEvent(huid.to_string()))
}
// TODO: maybe add an update_upcoming(date) ?
// ///
// pub fn contains_event(&self, id: &str) -> bool {
// self.pending_events.contains_key(id)
// }
}
/// The list of ongoing events, not yet closed
///
/// This struct represents the collection of events that have been initiated but have not yet concluded.
#[derive(Serialize, Deserialize, Default, Clone)]
#[cfg_attr(test, derive(Debug, PartialEq))]
pub struct ListOngoingEvents {
/// The list of ongoing events
pub(super) ongoing_events: OngoingHashmap,
}
impl ListOngoingEvents {
/// Add a new event to the list of ongoing events.
///
/// This function also launch the event based and adds a callback with the Huid of the original caller.
pub(crate) fn add_event(
&mut self,
huid: &EventIdType,
mut event: EventOngoing,
) -> Result<(), IdleError> {
event.parsed_vote.launch()?;
self.ongoing_events.insert(huid.clone(), event);
Ok(())
}
/// Remove all outdated votes for the current user
///
/// This function is expected to be called periodically by the watchdog.
pub(crate) fn autoclose(
&mut self,
current_time: NaiveDateTime,
ev_ctx: &EventHolder,
) -> Result<(), IdleError> {
let failure = Vec::new();
for huid in self.find_autoclose(current_time) {
self.close_event(&huid, ev_ctx)?;
}
match failure.is_empty() {
true => Ok(()),
// Should only happen during hard to reproduce race conditions
#[cfg(not(tarpaulin_include))]
false => Err(IdleError::EventPrune(failure)),
}
}
/// Close an event removing it from the ongoing event list and
/// puting it into the closed event list.
///
/// Doing so allow for the vote result to be read while it is valid
pub fn close_event(
&mut self,
huid: &EventIdType,
ev_ctx: &EventHolder,
) -> Result<(), IdleError> {
// TODO: Another vkypoint, as we cant continue without knowing how to send a message
let event = self
.ongoing_events
.remove(huid)
.ok_or(IdleError::LaunchingEvent(huid.to_string()))?;
ev_ctx
.closed_events
.lock()
.unwrap()
.add_event(huid.clone(), event.into_closed())?;
Ok(())
}
/// delete the event without launching it
pub fn del_event(&mut self, huid: &EventIdType) -> Result<EventOngoing, IdleError> {
self.ongoing_events
.remove(huid)
.ok_or(IdleError::DeleteEvent(huid.to_string()))
}
/// Find all events that are scheduled to be autoclosed.
///
/// Returns a vector of HUIDs corresponding to the old events.
pub(super) fn find_autoclose(&mut self, current_time: NaiveDateTime) -> Vec<EventIdType> {
self.ongoing_events
.iter()
.filter(|(_, e)| e.parsed_vote.close_date <= current_time)
.map(|(k, _)| k.clone())
.collect()
}
}
/// The list of closed events
///
/// This struct represents the collection of events that have been concluded,
/// to display the results of the votes.
#[derive(Serialize, Deserialize, Default)]
pub struct ListClosedEvents {
/// The list of closed events
pub(super) closed_events: ClosedHashmap,
}
impl ListClosedEvents {
/// Add a closed event to the list of closed events
pub fn add_event(&mut self, huid: EventIdType, event: EventClosed) -> Result<(), IdleError> {
self.closed_events.insert(huid, event);
Ok(())
}
/// Find all events that are too old and supposed to be pruned.
///
/// Returns a vector of HUIDs corresponding to the old events.
pub(super) fn find_old(&mut self, current_time: NaiveDateTime) -> Vec<EventIdType> {
self.closed_events
.iter()
.filter(|(_, e)| e.parsed_vote.auto_delete_date <= current_time)
.map(|(k, _)| k.clone())
.collect()
}
/// Remove all outdated votes for the current user
///
/// This function is expected to be called periodically by the watchdog.
pub(crate) fn prune_old(&mut self, current_time: NaiveDateTime) -> Result<(), IdleError> {
let mut failure = Vec::new();
for huid in self.find_old(current_time) {
println!("{}", huid);
if self.closed_events.remove(&huid).is_none() {
// Should only happen during hard to reproduce race conditions
#[cfg(not(tarpaulin_include))]
failure.push(huid.clone());
}
}
match failure.is_empty() {
true => Ok(()),
#[cfg(not(tarpaulin_include))]
false => Err(IdleError::EventPrune(failure)),
}
}
}
/// A generic event, holding an event and his type as variants,
/// doing so is the easiest way to pass an event around outside of the event lists
#[allow(dead_code)]
pub enum TypedEvent {
/// Event that is ongoing.
Ongoing(EventOngoing),
/// Event that has yet to be resolved.
Pending(EventPending),
/// Event that has been resolved and is pending deletion.
Closed(EventClosed),
}
#[cfg(test)]
mod tests {
use chrono::{Days, Local};
use crate::votes::{
add_pending_event, close_ongoing_event, del_ongoing_event, del_pending_event,
events::ParsedVote, make_into_ongoing_event,
};
use super::*;
macro_rules! g {
($ev: expr) => {
$ev.lock().unwrap()
};
}
// Test all structs can be safely initialized
#[test]
fn init_test() {
let ev_ctx = EventHolder::default();
assert!(ev_ctx.pending_events.lock().is_ok());
assert!(ev_ctx.ongoing_events.lock().is_ok());
}
#[test]
fn test_base_vote_handling() {
let ev = EventPending::default();
let ev_ctx = EventHolder::default();
// Can we add a vote ?
let id = add_pending_event(ev.clone(), &ev_ctx).unwrap();
// assert!(gimme!(ev_ctx.pending_events).contains_key(&id)); // Is the vote present ?
del_pending_event(&id, &ev_ctx).unwrap();
assert!(!g!(ev_ctx.pending_events).pending_events.contains_key(&id)); // Is the vote now deleted
let id = add_pending_event(ev.clone(), &ev_ctx).unwrap();
make_into_ongoing_event(&id, &ev_ctx).unwrap(); // Launching this event
assert!(!g!(ev_ctx.pending_events).pending_events.contains_key(&id)); // Is the vote now not pending
assert!(g!(ev_ctx.ongoing_events).ongoing_events.contains_key(&id)); // Is the vote now ongoing
close_ongoing_event(&id, &ev_ctx).unwrap();
assert!(!g!(ev_ctx.ongoing_events).ongoing_events.contains_key(&id)); // Is the vote now not ongoing
let id = add_pending_event(ev.clone(), &ev_ctx).unwrap();
make_into_ongoing_event(&id, &ev_ctx).unwrap(); // Launching this event
del_ongoing_event(&id, &ev_ctx).unwrap();
assert!(!g!(ev_ctx.ongoing_events).ongoing_events.contains_key(&id)); // Is the vote now not ongoing
}
#[test]
fn test_upcomming_events() {
let ev = EventHolder::default();
let now = Local::now().naive_local();
let later = now.checked_add_days(Days::new(1)).unwrap();
let very_later = now.checked_add_days(Days::new(3)).unwrap();
let very_very_later = now.checked_add_days(Days::new(7)).unwrap();
let event = EventPending {
parsed_vote: ParsedVote {
launch_date: later,
close_date: very_later,
auto_delete_date: very_very_later,
..Default::default()
},
};
assert!(now < later);
assert!(later < very_later);
let id = add_pending_event(event, &ev).unwrap();
assert!(g!(ev.pending_events).find_upcoming(now).is_empty()); // no upcomming events
assert!(g!(ev.closed_events).find_old(now).is_empty()); // no old events
assert!(g!(ev.ongoing_events).find_autoclose(now).is_empty()); // no old events
g!(ev.pending_events).process_upcoming(now, &ev).unwrap(); // nothing should be processed
g!(ev.closed_events).prune_old(now).unwrap(); // nothing should be processed
g!(ev.ongoing_events).autoclose(now, &ev).unwrap(); // nothing should be processed
assert!(g!(ev.pending_events).find_upcoming(now).is_empty()); // no upcomming events
assert!(g!(ev.closed_events).find_old(now).is_empty()); // no old events
assert!(g!(ev.ongoing_events).find_autoclose(now).is_empty()); // no old events
assert!(g!(ev.pending_events).pending_events.contains_key(&id)); // it's still here
assert!(!g!(ev.ongoing_events).ongoing_events.contains_key(&id)); // it's wasn't processed
assert!(!g!(ev.closed_events).closed_events.contains_key(&id)); // not deleted
// Now some time passed
assert_eq!(g!(ev.pending_events).find_upcoming(later), vec![id.clone()]); // one upcomming event
assert!(g!(ev.closed_events).find_old(later).is_empty()); // no old events
assert!(g!(ev.ongoing_events).find_autoclose(later).is_empty()); // no old events
g!(ev.pending_events).process_upcoming(later, &ev).unwrap(); // one event should be processed
g!(ev.closed_events).prune_old(later).unwrap(); // nothing should be processed
g!(ev.ongoing_events).autoclose(later, &ev).unwrap(); // nothing should be processed
assert!(!g!(ev.pending_events).pending_events.contains_key(&id)); // it's not here anymore
assert!(g!(ev.ongoing_events).ongoing_events.contains_key(&id)); // it was processed
assert!(!g!(ev.closed_events).closed_events.contains_key(&id)); // not deleted
// More time passed
assert!(g!(ev.pending_events).find_upcoming(very_later).is_empty()); // one upcomming event
assert_eq!(
g!(ev.ongoing_events).find_autoclose(very_later),
vec![id.clone()]
); // one old event
assert!(g!(ev.closed_events).find_old(very_later).is_empty()); // no old events
g!(ev.pending_events)
.process_upcoming(very_later, &ev)
.unwrap(); // no event should be processed
g!(ev.closed_events).prune_old(very_later).unwrap(); // nothing should be processed
g!(ev.ongoing_events).autoclose(very_later, &ev).unwrap(); // nothing should be processed
assert!(!g!(ev.pending_events).pending_events.contains_key(&id)); // it's not here anymore
assert!(!g!(ev.ongoing_events).ongoing_events.contains_key(&id)); // it was processed
assert!(g!(ev.closed_events).closed_events.contains_key(&id)); // it was processed
// More more time passed
assert!(g!(ev.pending_events)
.find_upcoming(very_very_later)
.is_empty()); // one upcomming event
assert_eq!(
g!(ev.closed_events).find_old(very_very_later),
vec![id.clone()]
); // one old event
assert!(g!(ev.ongoing_events)
.find_autoclose(very_very_later)
.is_empty()); // no old events
g!(ev.pending_events)
.process_upcoming(very_very_later, &ev)
.unwrap(); // no event should be processed
g!(ev.closed_events).prune_old(very_very_later).unwrap(); // nothing should be processed
g!(ev.ongoing_events)
.autoclose(very_very_later, &ev)
.unwrap(); // nothing should be processed
assert!(!g!(ev.pending_events).pending_events.contains_key(&id)); // it's not here anymore
assert!(!g!(ev.ongoing_events).ongoing_events.contains_key(&id)); // it was processed
// TODO: Check the status at several points
}
#[ignore]
#[test]
fn serialisation_check() {
todo!()
}
}

View File

@ -1,50 +0,0 @@
//! Module that handles all the logic related to votes within an application.
//!
//! This module provides the necessary structures and traits to manage events
//! and their corresponding votes. It includes:
//!
//! - Structs: `Event`, `Vote`, `PendingEvents`, and `OngoingEvents`.
//! - Traits: None at this time.
//! - Enums: `EventStatus` that represents different states an event can be in.
//!
//! Note:
//! - The types `UserDataType`, `VoteValueType`, and some fields are marked
//! as deprecated and should not be used.
//! They are placeholders for the actual data structures which need to be
//! defined correctly.
#![allow(deprecated)]
#![warn(clippy::missing_docs_in_private_items)]
mod ballots;
mod events;
mod helper_functions;
mod holders;
mod traits;
// Republish
pub use ballots::Ballot;
pub use events::{EventClosed, EventOngoing, EventPending};
pub use helper_functions::EventHolder;
pub use helper_functions::*;
pub use holders::{ListOngoingEvents, ListPendingEvents};
use std::collections::HashMap;
use crate::ids::EventIdType;
/// The hashmap of pending votes
type PendingHashmap = HashMap<EventIdType, EventPending>;
/// The hashmap of ongoing, opened votes
type OngoingHashmap = HashMap<EventIdType, EventOngoing>;
/// The hashmap of closed votes, still available for reading to check the results
type ClosedHashmap = HashMap<EventIdType, EventClosed>;
/// Placeholder user data type
///
/// Links back to an user
#[deprecated(note = "This is an incorrect type to define an user")]
pub type UserDataType = String;
/// What an user voted for
#[deprecated(note = "This is an incorrect type to define a voting ballot")]
pub type BallotValueType = String;

View File

@ -1,142 +0,0 @@
//! Module holding all inner voting traits
#![allow(dead_code)]
use std::collections::HashMap;
use super::{
holders::ListClosedEvents, EventClosed, EventOngoing, EventPending, ListOngoingEvents,
ListPendingEvents,
};
/// Signals that the object will let you borrow an inner dictionnary
///
/// Doing so will allow blanket implementations great for generic dictionnary handling
pub(crate) trait BorrowInner<R> {
/// Borrow the inner ongoing events
fn borrow_inner(&self) -> &HashMap<String, R>;
}
impl BorrowInner<EventClosed> for ListClosedEvents {
/// Borrow the inner ongoing events
fn borrow_inner(&self) -> &HashMap<String, EventClosed> {
&self.closed_events
}
}
impl BorrowInner<EventOngoing> for ListOngoingEvents {
/// Borrow the inner ongoing events
fn borrow_inner(&self) -> &HashMap<String, EventOngoing> {
&self.ongoing_events
}
}
impl BorrowInner<EventPending> for ListPendingEvents {
/// Borrow the inner ongoing events
fn borrow_inner(&self) -> &HashMap<String, EventPending> {
&self.pending_events
}
}
/// Signals that the object will let you mutably borrow an inner dictionnary
///
/// Doing so will allow blanket implementations great for generic dictionnary handling
pub(crate) trait BorrowMutInner<R> {
/// Borrow the inner ongoing events
fn borrow_mut_inner(&mut self) -> &mut HashMap<String, R>;
}
/// Blanket inner dictionnary implementation
///
/// This trait is meant to allow for inner dictionnary manipulation
pub(crate) trait EventManipulation<R> {
/// Get a key in the inner hashmap
fn get_key(&self, s: &str) -> Option<&R>;
// /// Insert a key in the inner hashmap
// fn insert(&self, s: &str);
}
impl<T, R> EventManipulation<R> for T
where
T: BorrowInner<R>,
{
fn get_key(&self, s: &str) -> Option<&R> {
self.borrow_inner().get(s)
}
}
#[cfg(test)]
mod tests {
use crate::votes::events::ParsedVote;
use super::*;
#[derive(Default)]
struct TestI {
inner: HashMap<String, usize>,
}
impl BorrowInner<usize> for TestI {
fn borrow_inner(&self) -> &HashMap<String, usize> {
&self.inner
}
}
impl BorrowMutInner<usize> for TestI {
fn borrow_mut_inner(&mut self) -> &mut HashMap<String, usize> {
&mut self.inner
}
}
impl BorrowMutInner<EventPending> for ListPendingEvents {
fn borrow_mut_inner(&mut self) -> &mut HashMap<String, EventPending> {
&mut self.pending_events
}
}
#[test]
fn test_borrow_impl() {
let mut i = TestI::default();
assert!(i.borrow_inner().is_empty());
i.borrow_mut_inner().insert("Bob".to_owned(), 3);
assert!(i.borrow_inner().contains_key("Bob"));
}
#[test]
fn test_blanket_implementation() {
let mut i = TestI::default();
assert!(i.get_key("blanket").is_none());
i.borrow_mut_inner().insert("blanket".to_owned(), 42);
assert!(i.get_key("blanket").is_some());
}
#[test]
fn test_manual_implementation() {
let (mut e, mut v, mut w) = (
ListClosedEvents::default(),
ListOngoingEvents::default(),
ListPendingEvents::default(),
);
let pv = ParsedVote::default();
assert!(e.get_key("blanket1").is_none());
e.add_event(
"blanket1".to_owned(),
EventClosed {
parsed_vote: pv.clone(),
},
)
.unwrap();
assert!(e.get_key("blanket1").is_some());
assert!(v.get_key("blanket2").is_none());
v.add_event(
&"blanket2".to_owned(),
EventOngoing {
parsed_vote: pv.clone(),
},
)
.unwrap();
assert!(v.get_key("blanket2").is_some());
assert!(w.get_key("blanket3").is_none());
w.borrow_mut_inner()
.insert("blanket3".to_owned(), EventPending::default());
assert!(w.get_key("blanket3").is_some());
}
}

View File

@ -1,183 +1,12 @@
//! The `scheduler` module contains the logic for managing time-based tasks and events.
//! It is responsible for running scheduled tasks and garbage collecting old events.
//! Event scheduler in charge of waiting out events and enabling them when times comes
//!
//! This module includes several components:
//! Features:
//! Time based garbage collector
//! Time managed events
//!
//!
//! - **Scheduler Thread**: A background thread that runs in an infinite loop,
//! checking for upcoming events and executing them when their scheduled times are reached.
//! - **Time-based Garbage Collection**: The scheduler periodically cleans up old events
//! that have passed their scheduled execution time, ensuring that memory usage remains efficient.
//!
//! Key functions in this module include:
//!
//! - `watchdog_update`: Updates the internal state of the scheduler,
//! checks for and runs upcoming events, and performs garbage collection if necessary.
use crate::votes::EventHolder;
use chrono::{DateTime, Local, NaiveDate};
use poise::serenity_prelude::{self, CacheHttp, ChannelId};
/// The main scheduler waiting and dispatch loop.
///
///
/// This function continuously waits for the specified time interval to elapse,
/// then spawns a blocking task to perform the `watchdog_update` function. The
/// loop continues indefinitely, allowing for continuous scheduling of the
/// `watchdog_update` task at the specified intervals.
#[cfg(not(tarpaulin_include))] // This loop is untestable instead the logic is kept to the minimal
pub async fn main_scheduler_loop(mut interval: tokio::time::Interval, ev_ctx: EventHolder) {
loop {
fk_around(&ev_ctx).await;
interval.tick().await;
// tokio::spawn(async {watchdog_update().await;}); // For async task
let ev = ev_ctx.clone();
tokio::task::spawn_blocking(move || watchdog_update(Local::now(), ev));
}
}
/// Close to finding out
#[cfg(not(tarpaulin_include))] // Just a test function
async fn fk_around(ev_ctx: &EventHolder) {
println!(
"In the fk_around function ({}):",
Local::now() // &ev_ctx
);
if let Some(discord_ctx) = ev_ctx.discord_ctx.lock().await.as_mut() {
println!("Fking around : {:#?}", discord_ctx);
let mut m = serenity_prelude::Message::default();
m.content = "Bob".into();
let r = discord_ctx
.http()
.send_message(ChannelId::new(1300786300143800351), Vec::new(), &m)
.await;
println!("{:?}", r);
}
}
/// The `watchdog_update` function updates the state of the watchdog and executes the necessary tasks.
///
/// This function takes the current time as an argument, which is used to determine whether a new day has passed
/// and to update the internal calendar state. It then lists all upcoming events that are scheduled to be run
/// and executes them. Additionally, it schedules any ongoing tasks for future execution.
///
/// If a new day has been detected (based on the current time), it prunes old events from the list of ongoing events.
// TODO: Thouroughly test
fn watchdog_update(current_time: DateTime<Local>, ev_ctx: EventHolder) {
// Update day and tell if a day passed
let is_new_day = update_date(current_time.date_naive(), &ev_ctx);
// List all upcoming events and run all events that should be ran
if let Err(e) = ev_ctx
.pending_events
.lock()
.unwrap()
.process_upcoming(current_time.naive_local(), &ev_ctx)
{
// Process the error, log it and try to recover, this error can only happen during a difficult
// to reproduce data race where a task would be edited or externally deleted just as it is about to be launched
#[cfg(not(tarpaulin_include))]
log::error!("{}:{} {:?}", file!(), line!(), e);
}
// Execute all scheduled tasks
// * Clean old events if a new day passed
if is_new_day {
if let Err(e) = ev_ctx
.closed_events
.lock()
.unwrap()
.prune_old(current_time.naive_local())
{
// Process the error, log it and try to recover, this error can only happen during a difficult
// to reproduce data race where a task would be edited or externally deleted just as it is about to be deleted
#[cfg(not(tarpaulin_include))]
log::error!("{}:{} {:?}", file!(), line!(), e);
}
if let Err(e) = ev_ctx
.ongoing_events
.lock()
.unwrap()
.autoclose(current_time.naive_local(), &ev_ctx)
{
// Process the error, log it and try to recover, this error can only happen during a difficult
// to reproduce data race where a task would be edited or externally deleted just as it is about to be closed
#[cfg(not(tarpaulin_include))]
log::error!("{}:{} {:?}", file!(), line!(), e);
}
}
// TODO: Save global state
}
// /// A lazily-initialized, thread-safe storage for the previous day's date.
// ///
// /// This constant is used to track when a new day has started. When a new day is detected,
// /// it updates this value to reflect the current date and time.
// static OLD_DATE: LazyLock<Mutex<NaiveDate>> =
// LazyLock::new(|| Mutex::new(Local::now().date_naive()));
/// The `update_date` function updates the internal calendar state by taking a new date and comparing it with the previous day's date.
///
/// It returns a boolean indicating whether a new day has passed.
/// This function is critical for determining when to prune old events from the ongoing event list.
/// ## Note
/// This whole function exists only in the purpose of manually testing the autopruning and autotesting of all time-related function.
fn update_date(date: NaiveDate, ev_ctx: &EventHolder) -> bool {
let old = ev_ctx.old_date.lock().unwrap().signed_duration_since(date);
if old.num_days() < 0 {
*ev_ctx.old_date.lock().unwrap() = date;
true
} else {
false
}
}
#[cfg(test)]
mod tests {
use chrono::Days;
use super::*;
#[test]
fn initialisation() {
let ev_ctx = EventHolder::default();
assert!(ev_ctx.old_date.lock().is_ok());
let date = Local::now().date_naive();
update_date(date, &ev_ctx);
assert!(!update_date(date, &ev_ctx));
}
#[test]
fn test_watchdog_update() {
let ctx = EventHolder::default();
let date = Local::now();
watchdog_update(date, ctx.clone());
let date2 = date.checked_add_days(Days::new(12)).unwrap();
assert!(update_date(date2.date_naive(), &ctx));
let date2 = date.checked_add_days(Days::new(14)).unwrap();
watchdog_update(date2, ctx.clone());
}
#[test]
#[ignore]
fn test_watchdog_pruning() {
// Add an event for a date
// Check that the watchdog erased it now that it is passed
// Check that if is set long in the past the event isn't launched as it is not valid and is instead destroyed immediately
// Check that an event cannot stay in memory if it is invalid or wont be launched
unimplemented!()
}
#[test]
#[ignore]
fn test_watchdog_launching() {
// Add an event for a date
// Check that the watchdog launched it
unimplemented!()
}
#[test]
#[ignore]
fn watchdog_autosave() {
// Check that every update of the watchdog saves the votes
unimplemented!()
}
// use super::*;
}

View File

@ -1,14 +0,0 @@
#[cfg(test)]
mod tests {
#[test]
fn generic_integration_test() {
use idlefox::ids::generate_id;
use idlefox::votes::{add_ongoing_event, EventHolder, EventPending};
let ev_ctx = EventHolder::default();
let huid = generate_id(); // A new id
let ongoing = EventPending::default().into_ongoing(); // A very legit event
add_ongoing_event(&huid, ongoing, &ev_ctx).unwrap();
}
}