Finish refactoring

src/groups/calls/events.rs

@@ -0,0 +1,228 @@
+use std::{collections::HashMap, sync::Arc};
+
+use async_trait::async_trait;
+use linkify::LinkFinder;
+use twilight_model::{gateway::payload::incoming::MessageCreate, id::Id};
+use twilight_validate::request::webhook_username;
+
+use crate::{
+    database::models::{Call, Channel},
+    discord::{images, sanitizing::SanitizeDiscordMarkdown},
+    framework::{
+        events::traits::{EventResult, OnMessageHandler},
+        runtime::Runtime,
+    },
+    state::State,
+};
+
+#[derive(Debug)]
+pub struct MessageRedirector;
+
+#[async_trait]
+impl OnMessageHandler<State> for MessageRedirector {
+    async fn on_message(&self, event: &MessageCreate, rt: Arc<Runtime<State>>) -> EventResult {
+        if event.author.bot || event.author.system.unwrap_or(false) {
+            return Ok(());
+        }
+
+        let prefixes = rt
+            .get_prefixes(event.guild_id.map(|i| i.get()), Some(event.author.id.get()))
+            .await;
+
+        if prefixes.iter().any(|prefix| {
+            event
+                .content
+                .to_ascii_lowercase()
+                .starts_with(&prefix.to_ascii_lowercase())
+        }) {
+            return Ok(());
+        }
+
+        let Some(channel) = Channel::get_by_id(event.channel_id.get(), &rt.state.db)
+            .await
+            .inspect_err(|e| {
+                log::error!(
+                    "Failed to get channel from DB when processing message create event! {e:?}"
+                );
+            })?
+        else {
+            return Ok(());
+        };
+
+        let call = if let Some(call_id) = channel.call_id {
+            if let Some(call) = Call::get_by_id(call_id, &rt.state.db)
+                .await
+                .inspect_err(|e| {
+                    log::error!(
+                        "Failed to get call from DB when processing message create event! {e:?}"
+                    );
+                })?
+            {
+                if !call.is_active() {
+                    return Ok(());
+                }
+
+                call
+            } else {
+                log::error!(
+                    "Call ID {} in channel {} does not correspond to an active call.",
+                    call_id,
+                    channel.id
+                );
+                return Ok(());
+            }
+        } else {
+            return Ok(());
+        };
+
+        let Some(opposite_channel) = Channel::get_by_id(
+            call.other_party_channel_id(event.channel_id.get()),
+            &rt.state.db,
+        )
+        .await
+        .inspect_err(|e| {
+            log::error!(
+                "Failed to get opposite channel from DB when processing message create event! {e:?}"
+            );
+        })?
+        else {
+            return Ok(());
+        };
+
+        let Some((webhook_id, webhook_token)) = opposite_channel
+            .webhook_id
+            .zip(opposite_channel.webhook_token)
+        else {
+            // Handle DM calls in the future.
+            return Ok(());
+        };
+
+        let profile = get_display_profile(event);
+
+        rt.http
+            .execute_webhook(Id::new(webhook_id), &webhook_token)
+            .allowed_mentions(None)
+            .username(&profile.name)
+            .avatar_url(&profile.avatar_url)
+            .content(&escape_message(event))
+            .await
+            .inspect_err(|e| {
+                log::error!(
+                    "Failed to send message to webhook for call {} in channel {}: {e:?}",
+                    call.id,
+                    opposite_channel.id
+                );
+            })?;
+
+        Ok(())
+    }
+}
+
+struct DisplayProfile {
+    pub name: String,
+    pub avatar_url: String,
+}
+
+fn get_display_profile(event: &MessageCreate) -> DisplayProfile {
+    let member = event.member.clone();
+
+    let name = if let Some(nick) = &member.clone().and_then(|member| member.nick) {
+        if webhook_username(nick).is_err() {
+            "Invalid Nickname".to_string()
+        } else {
+            nick.clone()
+        }
+    } else if let Some(name) = &event.author.global_name {
+        if webhook_username(name).is_err() {
+            "Invalid Global Name".to_string()
+        } else {
+            name.clone()
+        }
+    } else if webhook_username(&event.author.name).is_err() {
+        "Invalid Username".to_string()
+    } else {
+        event.author.name.clone()
+    };
+
+    let avatar_hash = member
+        .and_then(|inner| inner.avatar)
+        .or(event.author.avatar);
+    let avatar_url = images::get_avatar_url(
+        avatar_hash,
+        event.author.id.get(),
+        event.author.discriminator as u64,
+    );
+
+    DisplayProfile { name, avatar_url }
+}
+
+fn escape_message(event: &MessageCreate) -> String {
+    let mut message = event.content.to_string();
+
+    for mention in &event.mentions {
+        message = message.replace(
+            &format!("<@{}>", mention.id),
+            &format!("**@{}**", mention.name.sanitize(true)),
+        );
+    }
+
+    for mention in &event.mention_roles {
+        message = message.replace(&format!("<@&{mention}>"), "**@Role**");
+    }
+
+    for mention in &event.mention_channels {
+        message = message.replace(
+            &format!("<#{}>", mention.id),
+            &format!("**#{}**", mention.name.sanitize(true)),
+        );
+    }
+
+    let mut finder = LinkFinder::new();
+    finder.url_must_have_scheme(false);
+
+    for link in finder.links(&message.clone()) {
+        let url = link.as_str();
+
+        message = message.replace(url, &"\\#".repeat(url.len()));
+    }
+
+    let replacements: HashMap<char, Option<char>> = [
+        ('@', Some('a')),
+        ('0', Some('o')),
+        ('1', Some('i')),
+        ('2', Some('z')),
+        ('3', Some('e')),
+        ('4', Some('a')),
+        ('5', Some('s')),
+        ('6', Some('b')),
+        ('7', Some('t')),
+        ('8', Some('g')),
+        ('9', Some('q')),
+    ]
+    .iter()
+    .cloned()
+    .collect();
+
+    let normalized_unidecoded = unidecode::unidecode(&message)
+        .to_lowercase()
+        .split_whitespace()
+        .collect::<Vec<&str>>()
+        .join(" ");
+    let mut normalized = String::with_capacity(normalized_unidecoded.len());
+
+    for ch in normalized_unidecoded.chars() {
+        if let Some(&replacement) = replacements.get(&ch) {
+            if let Some(replacement) = replacement {
+                normalized.push(replacement);
+            }
+        } else if ch.is_alphanumeric() || ch.is_whitespace() {
+            normalized.push(ch);
+        }
+
+        // skip everything else (punctuation not in map, zero-width, etc.)
+    }
+
+    log::debug!("Escaped message: {normalized}");
+
+    message.sanitize(false)
+}