discord
/
manifold
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'feature/logging'

This commit is contained in:
Xyon 2023-09-19 12:53:23 +01:00
parent cdf823a94d 7609e2007e
commit 0354cc6569
Signed by: xyon
GPG Key ID: DD18155D6B18078D
3 changed files with 189 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.toml
View File

@ -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"

189
src/events.rs
View File

@ -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_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;
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(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("Message updated")
.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?;
}

1
src/lib.rs
View File

@ -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");