changes

Cargo.toml

@@ -10,7 +10,7 @@ debug = "none"
 debug-assertions = false
 strip = true
 panic = "abort"
-lto = "fat"
+lto = true
 
 
 
@@ -19,7 +19,9 @@ lto = "fat"
 dotenv = "0.15.0"
 regex = "1.11.1"
 once_cell = "1.20.3"
-
+sarcastic = { git = "https://github.com/DJMrTV/bored-yaml.git" }
+chrono = "0.4.39"
+reqwest = "0.12.12"
 
 [dependencies.tokio]
 version = "1.43.0"

src/emergency_report.rs

@@ -58,7 +58,7 @@ impl EventHandler for EmergencyReportHandler {
 
         let text = &response.inputs[0];
 
-        let emergency_channel = ChannelId::new(1286724627413864562);
+        let emergency_channel = ChannelId::new(1379768148420591666);
 
         let mut author = CreateEmbedAuthor::from(response.interaction.user);
 

src/fest_fax.rs

@@ -0,0 +1,194 @@
+use sarcastic::byaml::{Byaml, Node};
+use serenity::all::{ChannelId, Colour, Command, CommandId, CommandOptionType, Context, CreateCommand, CreateCommandOption, CreateEmbed, CreateEmbedAuthor, CreateInputText, CreateInteractionResponse, CreateInteractionResponseMessage, CreateMessage, CreateQuickModal, EventHandler, InputTextStyle, Interaction, Ready, ResolvedValue, Timestamp};
+use serenity::all::ResolvedValue::Attachment;
+use serenity::async_trait;
+use tokio::sync::OnceCell;
+use std::fmt::Write;
+use chrono::{DateTime, Utc};
+
+#[derive(Default)]
+pub struct FestFaxHandler{
+    command_id: OnceCell<CommandId>
+}
+
+#[derive(Debug)]
+struct TeamData{
+    color: [f32; 4],
+    name: String
+}
+
+fn read_team_data(node: &Node<'_>) -> Option<TeamData>{
+    let Node::DictionaryNode(node) = node else{
+        return None;
+    };
+
+    let Some(Node::StringValue(color)) = node.find("Color") else{
+        return None;
+    };
+
+    let Some(color): Option<[f32; 4]> = color.split(',')
+        .filter_map(|v| v.parse::<f32>().ok())
+        .collect::<Vec<f32>>().try_into().ok() else {
+        return None;
+    };
+
+    let Some(Node::DictionaryNode(names)) = node.find("Name") else{
+        return None;
+    };
+
+    let Some(Node::StringValue(name)) = names.find("EUen") else{
+        return None;
+    };
+
+    Some(TeamData{
+        name: name.to_string(),
+        color
+    })
+}
+
+#[async_trait]
+impl EventHandler for FestFaxHandler {
+    async fn ready(&self, ctx: Context, data_about_bot: Ready) {
+        let command = CreateCommand::new("process-fest-in-fax-machine")
+            .add_option(CreateCommandOption::new(CommandOptionType::String, "fes_tex_url", "Texture url")
+                .required(true))
+            .add_option(CreateCommandOption::new(CommandOptionType::String, "details", "Details")
+                .required(true))
+            .description("Announce a fest!");
+
+        let cmd = Command::create_global_command(&ctx.http, command).await.expect("unable to register command");
+
+        self.command_id.set(cmd.id).ok();
+    }
+
+    async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
+        let Interaction::Command(command_interaction) = interaction else {
+            return;
+        };
+
+        let Some(command_id) = self.command_id.get() else{
+            return;
+        };
+
+        if command_interaction.data.id != *command_id{
+            return
+        }
+
+        if command_interaction.user.id != 400291421799710720 {
+            command_interaction.create_response(
+                &ctx.http,
+                CreateInteractionResponse::Message(
+                    CreateInteractionResponseMessage::new()
+                        .content("nuh uh(cnd still isnt up so im using this to test for perms lol)")
+                )).await.ok();
+            return;
+        }
+
+
+        let options = command_interaction.data.options();
+
+
+        let Ok(byaml_data) = reqwest::get("https://dl.app.spfn.cc/p01/data/1/Festival.byaml").await else{
+            return;
+        };
+
+        let Ok(byaml_data) = byaml_data.bytes().await else{
+            return;
+        };
+
+        macro_rules! byaml_handle_error {
+            ($($stuff:tt)*) => {
+                match $($stuff)*{
+                    Ok(v) => v,
+                    Err(e) => {
+                        command_interaction.create_response(&ctx.http, CreateInteractionResponse::Message(
+                            CreateInteractionResponseMessage::new()
+                                .content(format!("an error ocurred whilest reading the byaml: {}", e)))).await.ok();
+                        return;
+                    }
+                }
+            };
+        }
+
+        let byaml = byaml_handle_error!(Byaml::new(&byaml_data));
+        let root_node = byaml_handle_error!(byaml.get_root_node());
+
+        let Node::DictionaryNode(dict) = root_node else {
+            return;
+        };
+
+        let Some(Node::ArrayNode(teams)) = dict.find("Teams") else {
+            return
+        };
+
+        let mut iter = teams.into_iter()
+            .filter_map(|v| v.ok());
+
+        let Some(alpha) = iter.next() else {
+            return;
+        };
+
+        let Some(bravo) = iter.next() else {
+            return;
+        };
+
+        let Some(alpha) = read_team_data(&alpha) else{
+            return;
+        };
+        let Some(bravo) = read_team_data(&bravo) else{
+            return;
+        };
+
+
+        let Some(Node::DictionaryNode(times)) = dict.find("Time") else {
+            return
+        };
+
+        let Some(Node::StringValue(start_time)) = times.find("Start") else {
+            return
+        };
+
+        let Ok(start_time) = DateTime::parse_from_rfc3339(start_time) else{
+            return;
+        };
+
+        let Some(Node::StringValue(end_time)) = times.find("End") else {
+            return
+        };
+
+        let Ok(end_time) = DateTime::parse_from_rfc3339(end_time) else{
+            return;
+        };
+
+        let Some(fest_image) = options.iter().find(|o| o.name == "fes_tex_url") else{
+            return;
+        };
+
+        let ResolvedValue::String(fest_image) = fest_image.value else {
+            return;
+        };
+
+
+        let Some(fest_file) = options.iter().find(|o| o.name == "details") else{
+            return;
+        };
+
+        let ResolvedValue::String(details) = fest_file.value else {
+            return;
+        };
+
+
+        command_interaction.create_response(&ctx.http, CreateInteractionResponse::Message(
+            CreateInteractionResponseMessage::new()
+                .embed(
+                    CreateEmbed::new()
+                        .image(fest_image)
+                        .field("Theme", format!("{} vs {}", alpha.name, bravo.name), false)
+                        .field("Starts", format!("<t:{}:R>", start_time.timestamp()), false)
+                        .field("End", format!("<t:{}:f>", end_time.timestamp()), true)
+                        .field("Details", details, true)
+                )
+            )
+        ).await.ok();
+    }
+}

src/main.rs

@@ -1,28 +1,23 @@
-mod error_codes;
-mod cheeseburger;
 mod ayy;
+mod cheeseburger;
+mod emergency_report;
+mod error_codes;
+mod fest_fax;
 mod miiverse_mod_application;
 mod too_fat;
-mod emergency_report;
 
-use std::env;
 use once_cell::sync::Lazy;
 use regex::Regex;
 use serenity::async_trait;
 use serenity::prelude::*;
-
+use std::env;
-
-
-
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() {
     dotenv::dotenv().ok();
 
     let token = env::var("PROFESSOR_TOKEN").expect("Token not specified");
-    let intents = GatewayIntents::GUILD_MESSAGES
+    let intents = GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT;
-        | GatewayIntents::MESSAGE_CONTENT;
-
 
     let mut client = Client::builder(&token, intents)
         .event_handler(error_codes::ErrorCodeHandler)
@@ -31,7 +26,9 @@ async fn main() {
         .event_handler(too_fat::TooFatHandler)
         .event_handler(emergency_report::EmergencyReportHandler::default())
         .event_handler(miiverse_mod_application::MiiverseModApplicationHandler::default())
-        .await.expect("unable to create client");
+        //.event_handler(fest_fax::FestFaxHandler::default())
+        .await
+        .expect("unable to create client");
 
     client.start().await.expect("error running bot");
 }