troll Fabius

Cargo.toml

@@ -7,13 +7,14 @@ edition = "2021"
 
 [dependencies]
 log = "0.4"
-env_logger = "0.9"
-chrono = "0.4"
-itertools = "0.10"
-tokio = {version = "1.20", features = ["rt-multi-thread", "signal"]}
-dashmap = "5.3.4"
+env_logger = "0.11.8"
+time = "0.3.41"
+itertools = "0.14"
+tokio = {version = "1.47", features = ["rt-multi-thread", "signal"]}
+dashmap = "6.1.0"
+reqwest = { version = "0.13.2", features = ["json"] }
 
 [dependencies.serenity]
-version = "0.11"
+version = "0.12"
 default-features = false
-features = ["builder", "cache", "client", "gateway", "http", "model", "utils", "rustls_backend"]
+features = ["builder", "cache", "client", "gateway", "http", "model", "utils", "rustls_backend"]

src/bin/spamcontest.rs

@@ -40,7 +40,7 @@ async fn main() -> ExitCode {
             .expect("error on waiting for shutdown signal");
 
         debug!("Shutting down...");
-        shard_manager.lock().await.shutdown_all().await;
+        shard_manager.shutdown_all().await;
     });
 
     match client.start().await {

src/lib.rs

@@ -1,17 +1,20 @@
 use dashmap::DashMap;
 use itertools::Itertools;
 use log::{debug, error, info};
+use serenity::all::{ActivityData, CreateEmbed, CreateMessage, TypingStartEvent};
 use serenity::client::{Context, EventHandler};
 use serenity::model::channel::Message;
+use serenity::model::colour::Colour;
 use serenity::model::event::ResumedEvent;
-use serenity::model::gateway::{Activity, Ready};
+use serenity::model::gateway::Ready;
 use serenity::model::id::{ChannelId, UserId};
-use serenity::utils::Colour;
 use std::cmp::Reverse;
 use std::collections::HashMap;
 use std::fmt::Display;
 use std::ops::RangeInclusive;
-use std::time::Duration;
+use std::sync::Mutex;
+use std::time::{Duration, Instant};
+use time::OffsetDateTime;
 use tokio::sync::mpsc;
 
 const DEFAULT_CONTEST_DURATION: Duration = Duration::from_secs(60);
@@ -26,23 +29,76 @@ type Contests = DashMap<ChannelId, mpsc::Sender<Message>>;
 #[derive(Default)]
 pub struct Handler {
     contests: Contests,
+    ntfy_typing_last: Mutex<Option<Instant>>,
+    http_client: reqwest::Client,
 }
 
 impl Handler {
     pub fn new() -> Self {
-        Self::default()
+        Self {
+            contests: Contests::new(),
+            ntfy_typing_last: Mutex::new(None),
+            http_client: reqwest::Client::builder()
+                .tls_danger_accept_invalid_certs(true)
+                .build()
+                .unwrap(),
+        }
     }
 }
 
+const NTFY_USER_ID: u64 = 313015629659635713;
+const NTFY_URL: &str = "https://ntfy.noisruker.de/up123456789TestTest";
+const NTFY_TYPING_TIMEOUT: Duration = Duration::from_secs(30);
+
 #[serenity::async_trait]
 impl EventHandler for Handler {
+    async fn typing_start(&self, _ctx: Context, event: TypingStartEvent) {
+        if event
+            .member
+            .is_some_and(|m| m.user.id.get() == NTFY_USER_ID)
+            && { self.ntfy_typing_last.lock() }
+                .unwrap()
+                .is_none_or(|i| i.elapsed() > NTFY_TYPING_TIMEOUT)
+        {
+            let res = self.http_client.post(NTFY_URL)
+            .header("Title", "Ich höre zu ...")
+            .header("Priority", "max")
+            .header("Tags", "ear")
+            .body("Du tippst gerade eine Nachricht auf Discord. Weiter so! Ich (wer auch immer ich sein mag) bin empfangsbereit.").send().await;
+            match res {
+                Ok(_) => info!("NTFY typing message sent"),
+                Err(error) => error!("NTFY error: {error}"),
+            }
+        }
+
+        *self.ntfy_typing_last.lock().unwrap() = Some(Instant::now());
+    }
+
     async fn message(&self, ctx: Context, msg: Message) {
+        if msg.author.id.get() == NTFY_USER_ID {
+            let res = self
+                .http_client
+                .post(NTFY_URL)
+                .header("Title", "Ich habe deine Nachricht erhalten!")
+                .header("Priority", "max")
+                .header("Tags", "mailbox_with_mail")
+                .body(format!("Du hast geschrieben: {}", msg.content))
+                .send()
+                .await;
+            match res {
+                Ok(_) => info!("NTFY message message sent"),
+                Err(error) => error!("NTFY error: {error}"),
+            }
+
+            *self.ntfy_typing_last.lock().unwrap() = None;
+        }
+
         if let Some(contest) = self.contests.get(&msg.channel_id) {
             debug!(
                 "Counting message {} (from {} in channel {})",
                 msg.id,
                 msg.author.tag(),
-                msg.channel_id.0
+                msg.channel_id.get()
             );
             contest.value().send(msg).await.unwrap();
             return;
@@ -61,7 +117,7 @@ impl EventHandler for Handler {
                 "User {} started a {} second contest in channel {}",
                 msg.author.tag(),
                 duration.as_secs(),
-                msg.channel_id.0
+                msg.channel_id.get()
             );
 
             match run_contest(
@@ -75,20 +131,21 @@ impl EventHandler for Handler {
             {
                 Ok(contest) => debug!(
                     "Contest in channel {} has ended with {} participant(s)",
-                    msg.channel_id.0,
+                    msg.channel_id.get(),
                     contest.counts.len()
                 ),
                 Err(err) => error!(
                     "Error while running contest in channel {}: {}",
-                    msg.channel_id.0, err
+                    msg.channel_id.get(),
+                    err
                 ),
             };
         }
     }
 
     async fn ready(&self, ctx: Context, ready: Ready) {
-        info!("Connected as {}", ready.user.tag());
-        ctx.set_activity(Activity::listening("Spam")).await;
+        info!("Connected as {} (troll)", ready.user.tag());
+        ctx.set_activity(Some(ActivityData::listening("Spam")));
     }
 
     async fn resume(&self, _ctx: Context, _: ResumedEvent) {
@@ -143,7 +200,7 @@ impl Contest {
 
         let mut result = String::new();
         let mut cur_rank_num = 1;
-        for (_, rank_group) in &ranking.into_iter().group_by(|elt| fk((*elt).1)) {
+        for (_, rank_group) in &ranking.into_iter().chunk_by(|elt| fk((elt).1)) {
             let mut group_size = 0;
             for (userid, count) in rank_group {
                 result.push_str(
@@ -164,20 +221,21 @@ async fn run_contest(
     contests: &Contests,
     pin: bool,
 ) -> serenity::Result<Contest> {
-    let end_timestamp =
-        (chrono::Utc::now() + chrono::Duration::from_std(duration).unwrap()).timestamp() + 1;
+    let end_timestamp = (OffsetDateTime::now_utc() + duration).unix_timestamp();
 
     // send announcement message
     let announcement = channel_id
-        .send_message(&ctx.http, |m| {
-            m.embed(|e| {
-                e.title("Es wurde ein Spam-Wettbewerb gestartet!")
+        .send_message(
+            &ctx.http,
+            CreateMessage::new().add_embed(
+                CreateEmbed::new()
+                    .title("Es wurde ein Spam-Wettbewerb gestartet!")
                     .description(format!(
                         "Wer am meisten spamt, gewinnt.\nEnde <t:{end_timestamp}:R>.",
                     ))
-                    .colour(Colour::BLUE)
-            })
-        })
+                    .colour(Colour::BLUE),
+            ),
+        )
         .await?;
 
     if pin {
@@ -211,9 +269,11 @@ async fn run_contest(
 
         // send ranking message
         channel_id
-            .send_message(&ctx.http, |m| {
-                m.embed(|e| {
-                    e.title("Der Wettbewerb ist beendet!")
+            .send_message(
+                &ctx.http,
+                CreateMessage::new().add_embed(
+                    CreateEmbed::new()
+                        .title("Der Wettbewerb ist beendet!")
                         .colour(Colour::DARK_GREEN)
                         .field(
                             "Ergebnisse (nach Nachrichten):",
@@ -224,9 +284,9 @@ async fn run_contest(
                             "Ergebnisse (nach Zeichen):",
                             counts.ranking_by(|c| Reverse(c.characters), |c| c.characters),
                             false,
-                        )
-                })
-            })
+                        ),
+                ),
+            )
             .await?;
     }