Merge pull request #296 from Rustmail/37-improve-log-display

feat(logs): improve logs display

Author: Akinator31

rustmail/src/handlers/audit_log/formatters/automod.rs

@@ -0,0 +1,74 @@
+use super::{format_change_value, EmbedField};
+use crate::handlers::audit_log::{
+    AuditLogContext, AuditLogFormatter, COLOR_DANGER, COLOR_INFO, COLOR_SUCCESS, COLOR_WARNING,
+};
+use serenity::all::AutoModAction;
+
+pub struct AutoModFormatter(pub AutoModAction);
+
+#[async_trait::async_trait]
+impl AuditLogFormatter for AutoModFormatter {
+    fn emoji(&self) -> &'static str {
+        match self.0 {
+            AutoModAction::RuleCreate => "🛡️",
+            AutoModAction::RuleUpdate => "✏️",
+            AutoModAction::RuleDelete => "🗑️",
+            AutoModAction::BlockMessage => "🚫",
+            AutoModAction::FlagToChannel => "🚩",
+            AutoModAction::UserCommunicationDisabled => "🔇",
+            _ => "🛡️",
+        }
+    }
+
+    fn color(&self) -> u32 {
+        match self.0 {
+            AutoModAction::RuleCreate => COLOR_SUCCESS,
+            AutoModAction::RuleUpdate => COLOR_WARNING,
+            AutoModAction::RuleDelete => COLOR_DANGER,
+            AutoModAction::BlockMessage => COLOR_DANGER,
+            AutoModAction::FlagToChannel => COLOR_WARNING,
+            AutoModAction::UserCommunicationDisabled => COLOR_INFO,
+            _ => COLOR_INFO,
+        }
+    }
+
+    async fn title(&self, alc: &AuditLogContext<'_>) -> String {
+        let key = match self.0 {
+            AutoModAction::RuleCreate => "audit_log.automod.rule_create",
+            AutoModAction::RuleUpdate => "audit_log.automod.rule_update",
+            AutoModAction::RuleDelete => "audit_log.automod.rule_delete",
+            AutoModAction::BlockMessage => "audit_log.automod.block_message",
+            AutoModAction::FlagToChannel => "audit_log.automod.flag_to_channel",
+            AutoModAction::UserCommunicationDisabled => "audit_log.automod.user_timeout",
+            _ => "audit_log.automod.unknown",
+        };
+        alc.translate(key, None).await
+    }
+
+    async fn description(&self, alc: &AuditLogContext<'_>) -> String {
+        let target_label = alc.translate("audit_log.target", None).await;
+
+        let target = if let Some(target_id) = alc.target_id() {
+            match self.0 {
+                AutoModAction::UserCommunicationDisabled => {
+                    format!("<@{}> (`{}`)", target_id, target_id)
+                }
+                _ => format!("`{}`", target_id),
+            }
+        } else {
+            alc.translate("audit_log.unknown", None).await
+        };
+
+        format!("**{}:** {}", target_label, target)
+    }
+
+    async fn format_changes(&self, alc: &AuditLogContext<'_>) -> Vec<EmbedField> {
+        let mut fields = Vec::new();
+        for change in alc.changes() {
+            if let Some(field) = format_change_value(alc, change).await {
+                fields.push(field);
+            }
+        }
+        fields
+    }
+}

rustmail/src/handlers/audit_log/formatters/channel.rs

@@ -0,0 +1,63 @@
+use super::{format_change_value, EmbedField};
+use crate::handlers::audit_log::{
+    AuditLogContext, AuditLogFormatter, COLOR_DANGER, COLOR_SUCCESS, COLOR_WARNING,
+};
+use serenity::all::ChannelAction;
+
+pub struct ChannelFormatter(pub ChannelAction);
+
+#[async_trait::async_trait]
+impl AuditLogFormatter for ChannelFormatter {
+    fn emoji(&self) -> &'static str {
+        match self.0 {
+            ChannelAction::Create => "📁",
+            ChannelAction::Update => "✏️",
+            ChannelAction::Delete => "🗑️",
+            _ => "📁",
+        }
+    }
+
+    fn color(&self) -> u32 {
+        match self.0 {
+            ChannelAction::Create => COLOR_SUCCESS,
+            ChannelAction::Update => COLOR_WARNING,
+            ChannelAction::Delete => COLOR_DANGER,
+            _ => COLOR_WARNING,
+        }
+    }
+
+    async fn title(&self, alc: &AuditLogContext<'_>) -> String {
+        let key = match self.0 {
+            ChannelAction::Create => "audit_log.channel.create",
+            ChannelAction::Update => "audit_log.channel.update",
+            ChannelAction::Delete => "audit_log.channel.delete",
+            _ => "audit_log.channel.unknown",
+        };
+        alc.translate(key, None).await
+    }
+
+    async fn description(&self, alc: &AuditLogContext<'_>) -> String {
+        let target_label = alc.translate("audit_log.target", None).await;
+
+        let target = if let Some(target_id) = alc.target_id() {
+            match self.0 {
+                ChannelAction::Delete => format!("`{}`", target_id),
+                _ => format!("<#{}> (`{}`)", target_id, target_id),
+            }
+        } else {
+            alc.translate("audit_log.unknown", None).await
+        };
+
+        format!("**{}:** {}", target_label, target)
+    }
+
+    async fn format_changes(&self, alc: &AuditLogContext<'_>) -> Vec<EmbedField> {
+        let mut fields = Vec::new();
+        for change in alc.changes() {
+            if let Some(field) = format_change_value(alc, change).await {
+                fields.push(field);
+            }
+        }
+        fields
+    }
+}

rustmail/src/handlers/audit_log/formatters/channel_overwrite.rs

@@ -0,0 +1,60 @@
+use super::{format_change_value, EmbedField};
+use crate::handlers::audit_log::{
+    AuditLogContext, AuditLogFormatter, COLOR_DANGER, COLOR_SUCCESS, COLOR_WARNING,
+};
+use serenity::all::ChannelOverwriteAction;
+
+pub struct ChannelOverwriteFormatter(pub ChannelOverwriteAction);
+
+#[async_trait::async_trait]
+impl AuditLogFormatter for ChannelOverwriteFormatter {
+    fn emoji(&self) -> &'static str {
+        match self.0 {
+            ChannelOverwriteAction::Create => "🔐",
+            ChannelOverwriteAction::Update => "🔑",
+            ChannelOverwriteAction::Delete => "🔓",
+            _ => "🔐",
+        }
+    }
+
+    fn color(&self) -> u32 {
+        match self.0 {
+            ChannelOverwriteAction::Create => COLOR_SUCCESS,
+            ChannelOverwriteAction::Update => COLOR_WARNING,
+            ChannelOverwriteAction::Delete => COLOR_DANGER,
+            _ => COLOR_WARNING,
+        }
+    }
+
+    async fn title(&self, alc: &AuditLogContext<'_>) -> String {
+        let key = match self.0 {
+            ChannelOverwriteAction::Create => "audit_log.channel_overwrite.create",
+            ChannelOverwriteAction::Update => "audit_log.channel_overwrite.update",
+            ChannelOverwriteAction::Delete => "audit_log.channel_overwrite.delete",
+            _ => "audit_log.channel_overwrite.unknown",
+        };
+        alc.translate(key, None).await
+    }
+
+    async fn description(&self, alc: &AuditLogContext<'_>) -> String {
+        let target_label = alc.translate("audit_log.target", None).await;
+
+        let target = if let Some(target_id) = alc.target_id() {
+            format!("<#{}> (`{}`)", target_id, target_id)
+        } else {
+            alc.translate("audit_log.unknown", None).await
+        };
+
+        format!("**{}:** {}", target_label, target)
+    }
+
+    async fn format_changes(&self, alc: &AuditLogContext<'_>) -> Vec<EmbedField> {
+        let mut fields = Vec::new();
+        for change in alc.changes() {
+            if let Some(field) = format_change_value(alc, change).await {
+                fields.push(field);
+            }
+        }
+        fields
+    }
+}

rustmail/src/handlers/audit_log/formatters/creator_monetization.rs

@@ -0,0 +1,41 @@
+use super::EmbedField;
+use crate::handlers::audit_log::{AuditLogContext, AuditLogFormatter, COLOR_SUCCESS};
+use serenity::all::CreatorMonetizationAction;
+
+pub struct CreatorMonetizationFormatter(pub CreatorMonetizationAction);
+
+#[async_trait::async_trait]
+impl AuditLogFormatter for CreatorMonetizationFormatter {
+    fn emoji(&self) -> &'static str {
+        match self.0 {
+            CreatorMonetizationAction::RequestCreated => "💰",
+            CreatorMonetizationAction::TermsAccepted => "✅",
+            _ => "💰",
+        }
+    }
+
+    fn color(&self) -> u32 {
+        COLOR_SUCCESS
+    }
+
+    async fn title(&self, alc: &AuditLogContext<'_>) -> String {
+        let key = match self.0 {
+            CreatorMonetizationAction::RequestCreated => {
+                "audit_log.creator_monetization.request_created"
+            }
+            CreatorMonetizationAction::TermsAccepted => {
+                "audit_log.creator_monetization.terms_accepted"
+            }
+            _ => "audit_log.creator_monetization.unknown",
+        };
+        alc.translate(key, None).await
+    }
+
+    async fn description(&self, _alc: &AuditLogContext<'_>) -> String {
+        String::new()
+    }
+
+    async fn format_changes(&self, _alc: &AuditLogContext<'_>) -> Vec<EmbedField> {
+        Vec::new()
+    }
+}

rustmail/src/handlers/audit_log/formatters/emoji.rs

@@ -0,0 +1,60 @@
+use super::{format_change_value, EmbedField};
+use crate::handlers::audit_log::{
+    AuditLogContext, AuditLogFormatter, COLOR_DANGER, COLOR_SUCCESS, COLOR_WARNING,
+};
+use serenity::all::EmojiAction;
+
+pub struct EmojiFormatter(pub EmojiAction);
+
+#[async_trait::async_trait]
+impl AuditLogFormatter for EmojiFormatter {
+    fn emoji(&self) -> &'static str {
+        match self.0 {
+            EmojiAction::Create => "😀",
+            EmojiAction::Update => "✏️",
+            EmojiAction::Delete => "🗑️",
+            _ => "😀",
+        }
+    }
+
+    fn color(&self) -> u32 {
+        match self.0 {
+            EmojiAction::Create => COLOR_SUCCESS,
+            EmojiAction::Update => COLOR_WARNING,
+            EmojiAction::Delete => COLOR_DANGER,
+            _ => COLOR_WARNING,
+        }
+    }
+
+    async fn title(&self, alc: &AuditLogContext<'_>) -> String {
+        let key = match self.0 {
+            EmojiAction::Create => "audit_log.emoji.create",
+            EmojiAction::Update => "audit_log.emoji.update",
+            EmojiAction::Delete => "audit_log.emoji.delete",
+            _ => "audit_log.emoji.unknown",
+        };
+        alc.translate(key, None).await
+    }
+
+    async fn description(&self, alc: &AuditLogContext<'_>) -> String {
+        let target_label = alc.translate("audit_log.target", None).await;
+
+        let target = if let Some(target_id) = alc.target_id() {
+            format!("`{}`", target_id)
+        } else {
+            alc.translate("audit_log.unknown", None).await
+        };
+
+        format!("**{}:** {}", target_label, target)
+    }
+
+    async fn format_changes(&self, alc: &AuditLogContext<'_>) -> Vec<EmbedField> {
+        let mut fields = Vec::new();
+        for change in alc.changes() {
+            if let Some(field) = format_change_value(alc, change).await {
+                fields.push(field);
+            }
+        }
+        fields
+    }
+}

rustmail/src/handlers/audit_log/formatters/guild.rs

@@ -0,0 +1,35 @@
+use super::{format_change_value, EmbedField};
+use crate::handlers::audit_log::{AuditLogContext, AuditLogFormatter, COLOR_WARNING};
+
+pub enum GuildFormatter {
+    Update,
+}
+
+#[async_trait::async_trait]
+impl AuditLogFormatter for GuildFormatter {
+    fn emoji(&self) -> &'static str {
+        "⚙️"
+    }
+
+    fn color(&self) -> u32 {
+        COLOR_WARNING
+    }
+
+    async fn title(&self, alc: &AuditLogContext<'_>) -> String {
+        alc.translate("audit_log.guild.update", None).await
+    }
+
+    async fn description(&self, _alc: &AuditLogContext<'_>) -> String {
+        String::new()
+    }
+
+    async fn format_changes(&self, alc: &AuditLogContext<'_>) -> Vec<EmbedField> {
+        let mut fields = Vec::new();
+        for change in alc.changes() {
+            if let Some(field) = format_change_value(alc, change).await {
+                fields.push(field);
+            }
+        }
+        fields
+    }
+}

rustmail/src/handlers/audit_log/formatters/integration.rs

@@ -0,0 +1,60 @@
+use super::{format_change_value, EmbedField};
+use crate::handlers::audit_log::{
+    AuditLogContext, AuditLogFormatter, COLOR_DANGER, COLOR_SUCCESS, COLOR_WARNING,
+};
+use serenity::all::IntegrationAction;
+
+pub struct IntegrationFormatter(pub IntegrationAction);
+
+#[async_trait::async_trait]
+impl AuditLogFormatter for IntegrationFormatter {
+    fn emoji(&self) -> &'static str {
+        match self.0 {
+            IntegrationAction::Create => "🔗",
+            IntegrationAction::Update => "✏️",
+            IntegrationAction::Delete => "🗑️",
+            _ => "🔗",
+        }
+    }
+
+    fn color(&self) -> u32 {
+        match self.0 {
+            IntegrationAction::Create => COLOR_SUCCESS,
+            IntegrationAction::Update => COLOR_WARNING,
+            IntegrationAction::Delete => COLOR_DANGER,
+            _ => COLOR_WARNING,
+        }
+    }
+
+    async fn title(&self, alc: &AuditLogContext<'_>) -> String {
+        let key = match self.0 {
+            IntegrationAction::Create => "audit_log.integration.create",
+            IntegrationAction::Update => "audit_log.integration.update",
+            IntegrationAction::Delete => "audit_log.integration.delete",
+            _ => "audit_log.integration.unknown",
+        };
+        alc.translate(key, None).await
+    }
+
+    async fn description(&self, alc: &AuditLogContext<'_>) -> String {
+        let target_label = alc.translate("audit_log.target", None).await;
+
+        let target = if let Some(target_id) = alc.target_id() {
+            format!("`{}`", target_id)
+        } else {
+            alc.translate("audit_log.unknown", None).await
+        };
+
+        format!("**{}:** {}", target_label, target)
+    }
+
+    async fn format_changes(&self, alc: &AuditLogContext<'_>) -> Vec<EmbedField> {
+        let mut fields = Vec::new();
+        for change in alc.changes() {
+            if let Some(field) = format_change_value(alc, change).await {
+                fields.push(field);
+            }
+        }
+        fields
+    }
+}