Merge branch 'feature/logging'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "manifold"
-version = "3.1.1"
+version = "3.2.0"
 authors = ["Lucy Bladen <admin@lbladen.uk>"]
 edition = "2021"
 
@@ -22,7 +22,7 @@ dirs = "5.0.1"
 env_logger = "0.10.0"
 log = "0.4.14"
 num = "0.4.1"
-poise = "0.5.5"
+poise = { version = "0.5.*", features = [ "cache" ] }
 r2d2 = "0.8.9"
 rand = "0.8.5"
 regex = "1.5.4"

src/events.rs

@@ -4,7 +4,7 @@ use poise::{Event, FrameworkContext};
 use poise::serenity_prelude::model::{
     gateway::Ready,
 };
-use poise::serenity_prelude::{Context, Message};
+use poise::serenity_prelude::{ChannelId, Colour, Context, GuildId, Member, Message, MessageId, Role, RoleId, Timestamp, User};
 use crate::ManifoldData;
 use crate::error::{ManifoldError, ManifoldResult};
 use crate::models::user::UserInfo;
@@ -23,7 +23,16 @@ impl Handler {
     pub async fn listen(ctx: &Context, framework_ctx: FrameworkContext<'_, ManifoldData, ManifoldError>, event: &Event<'_>) -> ManifoldResult<()> {
         match event {
             Event::Ready { data_about_bot} => Handler::standard_startup(&ctx, &framework_ctx, data_about_bot).await,
+            Event::GuildBanAddition { guild_id, banned_user } => Handler::ban_add(&ctx, &framework_ctx, guild_id, banned_user).await,
+            Event::GuildBanRemoval { guild_id, unbanned_user } => Handler::ban_remove(&ctx, &framework_ctx, guild_id, unbanned_user).await,
+            Event::GuildMemberAddition { new_member } => Handler::new_member(&ctx, &framework_ctx, &new_member).await,
+            Event::GuildMemberRemoval { guild_id, user, member_data_if_available } => Handler::member_leave(&ctx, &framework_ctx, guild_id, user, member_data_if_available).await,
+            Event::GuildMemberUpdate { old_if_available, new } => Handler::member_update(&ctx, &framework_ctx, old_if_available, new).await,
+            Event::GuildRoleCreate { new } => Handler::new_role(&ctx, &framework_ctx, new).await,
+            Event::GuildRoleDelete { guild_id, removed_role_id, removed_role_data_if_available } => Handler::delete_role(&ctx, &framework_ctx, guild_id, removed_role_id, removed_role_data_if_available).await,
+            Event::GuildRoleUpdate { old_data_if_available, new } => Handler::update_role(&ctx, &framework_ctx, old_data_if_available, new).await,
             Event::Message { new_message } => Handler::message(&ctx, &framework_ctx, &new_message).await,
+            Event::MessageDelete { channel_id, deleted_message_id, guild_id } => Handler::message_deleted(&ctx, &framework_ctx, channel_id, deleted_message_id, guild_id).await,
             Event::MessageUpdate { old_if_available, new, event: _event } => Handler::message_edited(&ctx, &framework_ctx, old_if_available, new).await,
             _ => Ok(())
         }
@@ -53,6 +62,141 @@ impl Handler {
         Ok(())
     }
 
+    async fn ban_add(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _guild_id: &GuildId, banned_user: &User) -> ManifoldResult<()> {
+        let log_channel = fctx.user_data().await.bot_config.channels.log;
+
+        log_channel.send_message(ctx, |f| {
+            f
+                .content("")
+                .embed(|e| {
+                    e
+                        .title(format!("{} was banned", banned_user.name))
+                        .colour(Colour::from_rgb(255, 0, 0))
+                        .timestamp(Timestamp::now())
+                })
+        }).await?;
+
+        Ok(())
+    }
+
+    async fn ban_remove(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _guild_id: &GuildId, unbanned_user: &User) -> ManifoldResult<()> {
+        let log_channel = fctx.user_data().await.bot_config.channels.log;
+
+        log_channel.send_message(ctx, |f| {
+            f
+                .content("")
+                .embed(|e| {
+                    e
+                        .title(format!("Ban was lifted for {}", unbanned_user.name))
+                        .colour(Colour::from_rgb(0, 255, 0))
+                        .timestamp(Timestamp::now())
+                })
+        }).await?;
+
+        Ok(())
+    }
+
+    async fn new_member(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, new_member: &Member) -> ManifoldResult<()> {
+        let log_channel = fctx.user_data().await.bot_config.channels.log;
+
+        log_channel.send_message(ctx, |f| {
+            f
+                .content("")
+                .embed(|e| {
+                    e
+                        .title(format!("{} joined the server with nickname {} ({})", new_member.user.name, new_member.nick.as_ref().unwrap_or(&new_member.user.name), new_member.user.id))
+                        .colour(Colour::from_rgb(0, 255, 0))
+                        .timestamp(new_member.joined_at.unwrap_or(Timestamp::now()))
+                        .field("Account creation date", new_member.user.created_at(), false)
+                })
+        }).await?;
+
+        Ok(())
+    }
+
+    async fn member_leave(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _guild_id: &GuildId, user: &User, _member_data_if_available: &Option<Member>) -> ManifoldResult<()> {
+        let log_channel = fctx.user_data().await.bot_config.channels.log;
+
+        log_channel.send_message(ctx, |f| {
+            f
+                .content("")
+                .embed(|e| {
+                    e
+                        .title(format!("{} left the server", user.name))
+                        .colour(Colour::from_rgb(255, 0, 0))
+                        .timestamp(Timestamp::now())
+                })
+        }).await?;
+
+        Ok(())
+    }
+
+    async fn member_update(_ctx: &Context, _fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _old_if_available: &Option<Member>, _new: &Member) -> ManifoldResult<()> {
+
+        Ok(())
+    }
+
+    async fn new_role(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, new: &Role) -> ManifoldResult<()> {
+        let log_channel = fctx.user_data().await.bot_config.channels.log;
+
+        log_channel.send_message(ctx, |f| {
+            f
+                .content("")
+                .embed(|e| {
+                    e
+                        .title(format!("New role {} ({}) was created", &new.name, &new.id))
+                        .colour(Colour::from_rgb(0, 255, 0))
+                        .timestamp(Timestamp::now())
+                        .field("Role Permissions", &new.permissions, false)
+                        .field("Hoist", &new.hoist, true)
+                        .field("Icon", &new.icon.clone().unwrap_or("None set".to_string()), true)
+                        .field("Mentionable", &new.mentionable, true)
+
+                })
+        }).await?;
+
+        Ok(())
+    }
+
+
+    async fn delete_role(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, _guild_id: &GuildId, removed_role_id: &RoleId, removed_role_data_if_available: &Option<Role>) -> ManifoldResult<()> {
+        let log_channel = fctx.user_data().await.bot_config.channels.log;
+
+        log_channel.send_message(ctx, |f| {
+            f
+                .content("")
+                .embed(|e| {
+
+                   match removed_role_data_if_available {
+                       Some(role) => {
+                           return e
+                               .title(format!("Role {} ({}) was deleted", &role.name, &role.id))
+                               .colour(Colour::from_rgb(255, 0, 0))
+                               .timestamp(Timestamp::now())
+                               .field("Role Permissions", &role.permissions, false)
+                               .field("Hoist", &role.hoist, true)
+                               .field("Icon", &role.icon.clone().unwrap_or("None set".to_string()), true)
+                               .field("Mentionable", &role.mentionable, true)
+                       },
+                       None => {
+                           return e
+                               .title(format!("Role {} was deleted (Role was not cached)", removed_role_id))
+                               .colour(Colour::from_rgb(255, 0, 0))
+                               .timestamp(Timestamp::now())
+                       }
+                   };
+                })
+        }).await?;
+
+        Ok(())
+    }
+
+
+    async fn update_role(_ctx: &Context, _fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>,  _old_data_if_available: &Option<Role>, _new: &Role) -> ManifoldResult<()> {
+
+        Ok(())
+    }
+
     async fn message(_ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, msg: &Message) -> ManifoldResult<()> {
         let userinfo = &mut fctx.user_data().await.user_info.lock().await;
 
@@ -74,23 +218,62 @@ impl Handler {
         Ok(())
     }
 
-    async fn message_edited(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, original: &Option<Message>, new_message: &Option<Message>) -> ManifoldResult<()> {
+    async fn message_deleted(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, channel_id: &ChannelId, deleted_message_id: &MessageId, _guild_id: &Option<GuildId>) -> ManifoldResult<()> {
         let log_channel = fctx.user_data().await.bot_config.channels.log;
 
-        if let Some(new) = new_message.as_ref() {
+        let mut content: String = "Not Available / Not Cached".to_string();
+        let author;
+
+        let channel = match ctx.cache.guild_channel(channel_id) {
+            Some(c) => c.name,
+            None => format!("Not Available / Not Cached ({})", channel_id)
+        };
+
+        if let Some(msg) = ctx.cache.message(channel_id, deleted_message_id) {
+            content = msg.content_safe(&ctx.cache);
+            author = msg.author;
+        } else {
+            author = User::default();
+        }
+
         log_channel.send_message(ctx, |f| {
             f
                 .content("")
                 .embed(|e| {
                     e
-                            .title("Message updated")
+                        .title(format!("Message removed in #{} ({})", channel, channel_id ))
+                        .colour(Colour::from_rgb(255, 0, 0))
+                        .author(|a| a.name(author.name))
+                        .field("Message Content", content, false)
+                        .timestamp(Timestamp::now())
+                        .footer(|f| f.text(author.id))
+                })
+        }).await?;
+
+        Ok(())
+    }
+
+    async fn message_edited(ctx: &Context, fctx: &FrameworkContext<'_, ManifoldData, ManifoldError>, original: &Option<Message>, new_message: &Option<Message>) -> ManifoldResult<()> {
+        let log_channel = fctx.user_data().await.bot_config.channels.log;
+
+        if let Some(new) = new_message.as_ref() {
+            let message_channel = new.channel_id.name(ctx).await.unwrap_or("Unknown Channel".to_string());
+            log_channel.send_message(ctx, |f| {
+                f
+                    .content("")
+                    .embed(|e| {
+                        e
+                            .title(format!("Message updated in #{} ({})", message_channel, new.channel_id))
+                            .colour(Colour::from_rgb(255, 153, 0))
                             .author(|a| a.name(new.author.name.clone()))
-                            .timestamp(new.timestamp)
+                            .timestamp(Timestamp::now())
                             .field("Original Content", match original.as_ref() {
                                 Some(m) => m.content.clone(),
                                 None => "Not available".to_string(),
                             }, false)
                             .field("New Content", new.content.clone(), false)
+                            .field("Message created at", new.timestamp, true)
+                            .field("Message author", &new.author.id, true)
                     })
             }).await?;
         }

src/lib.rs

@@ -114,6 +114,7 @@ pub async fn prepare_client(arguments: ArgMatches, intents: GatewayIntents, inje
             Box::pin(async move {
                 poise::builtins::register_globally(ctx, &framework.options().commands).await?;
                 ctx.set_activity(Activity::watching("you")).await;
+                ctx.cache.set_max_messages(350);
                 let db = Db { pool };
                 apply_migrations(&mut db.get()?);
                 let user_info = UserInfo::load(&db).expect("Could not load user info, rejecting");