+#![feature(if_let_guard, let_chains)]

+use anyhow::Result;

+use emoji::named::*;

+use poise::{serenity_prelude::*, CreateReply};

+use std::convert::identity;

+use std::fs::read_to_string;

+use std::pin::pin;

+use std::sync::Arc;

+use std::time::Duration;

+

+#[macro_export]

+macro_rules! send {

+ ($e:expr, $fmt:literal $(, $args:expr)* $(,)?) => {

+ $e.send(format!($fmt $(, $args)*))

+ };

+}

+

+fn last() -> u64 {

+ std::fs::read("last")

+ .ok()

+ .map(|x| {

+ x.into_iter()

+ .fold(0u64, |acc, x| acc * 10 + (x - b'0') as u64)

+ })

+ .unwrap_or(0)

+}

+

+fn set_last(x: u64) {

+ std::fs::write("last", x.to_string()).unwrap();

+}

+

+pub fn format(log: AuditLogEntry) -> Option<String> {

+ use serenity::model::guild::audit_log::Action::*;

+ use serenity::model::guild::audit_log::Change::*;

+ let changes = log

+ .changes

+ .iter()

+ .flatten()

+ .into_iter()

+ .map(|x| {

+ Some(match x {

+ Nick { old, new } => {

+ format!("nick ~~{}~~ {RIGHT} {}", old.as_ref()?, new.as_ref()?)

+ }

+ Name { old, new } => {

+ format!("name ~~{}~~ {RIGHT} {}", old.as_ref()?, new.as_ref()?)

+ }

+ RolesRemove { new, .. } => new

+ .as_ref()?

+ .into_iter()

+ .map(|x| format!("{ADD} <@&{}>", x.id))

+ .reduce(|a, b| format!("{a} {b}"))

+ .unwrap_or_else(String::new),

+ RolesAdded { new, .. } => new

+ .as_ref()?

+ .into_iter()

+ .map(|x| format!("{CANCEL} <@&{}>", x.id))

+ .reduce(|a, b| format!("{a} {b}"))

+ .unwrap_or_else(String::new),

+ _ => return None,

+ })

+ })

+ .filter_map(identity)

+ .reduce(|a, b| format!("{a}\n{b}"))

+ .unwrap_or_else(String::new);

+ Some(format!(

+ "<t:{}:d> <@{}> {}",

+ log.id.created_at().unix_timestamp(),

+ log.user_id,

+ match log.action {

+ GuildUpdate => format!("guild changes\n{changes}"),

+ Channel(ChannelAction::Create) => format!("{ADD} channel\n{changes}"),

+ Channel(ChannelAction::Delete) => format!("{CANCEL} channel\n{changes}"),

+ Channel(ChannelAction::Update) => format!("{ROTATE} channel\n{changes}"),

+ Member(MemberAction::Kick | MemberAction::BanAdd) =>

+ format!("{HAMMER} <@{}>", log.target_id?),

+ Member(MemberAction::RoleUpdate)

+ if let Some(t) = log.target_id

+ && t.get() != log.user_id.get() =>

+ {

+ format!("{ROTATE} roles of <@{t}>: {changes}")

+ }

+ Member(MemberAction::RoleUpdate) => format!("{ROTATE} roles: {changes}"),

+ Message(MessageAction::Delete) =>

+ format!("{CANCEL} deleted message by <@{}>", log.target_id?),

+ _ => return None,

+ }

+ ))

+}

+

+const PFX: char = '}';

+

+async fn lop(c: serenity::client::Context) {

+ let c = &c;

+ let g = c.http().get_guild(925674713429184564.into()).await.unwrap();

+ let ch = g.channel_id_from_name(c, "server-logs").unwrap();

+ loop {

+ let l = last();

+ for log in g

+ .audit_logs(c, None, None, None, None)

+ .await

+ .unwrap()

+ .entries

+ .into_iter()

+ .rev()

+ .filter(|x| x.id.created_at().unix_timestamp() as u64 > l)

+ {

+ let Some(h) = format(log.clone()) else {

+ continue;

+ };

+ ch.send_message(

+ c,

+ CreateMessage::new()

+ .allowed_mentions(CreateAllowedMentions::new().empty_users().empty_roles())

+ .content(h),

+ )

+ .await

+ .unwrap();

+ }

+ set_last(

+ std::time::SystemTime::now()

+ .duration_since(std::time::UNIX_EPOCH)

+ .unwrap()

+ .as_secs(),

+ );

+ // every minute

+ tokio::time::sleep(Duration::from_secs(60)).await;

+ }

+}

+pub struct Bot;

+impl Bot {

+ pub async fn spawn() {

+ println!("bot startup");

+ let tok =

+ std::env::var("TOKEN").unwrap_or_else(|_| read_to_string("token").expect("wher token"));

+ let f = poise::Framework::builder()

+ .options(poise::FrameworkOptions {

+ commands: vec![help(), prune(), run()],

+ on_error: |e| Box::pin(on_error(e)),

+ prefix_options: poise::PrefixFrameworkOptions {

+ edit_tracker: Some(Arc::new(poise::EditTracker::for_timespan(

+ std::time::Duration::from_secs(2 * 60),

+ ))),

+ prefix: Some(PFX.to_string()),

+ ..Default::default()

+ },

+ ..Default::default()

+ })

+ .setup(|ctx, _ready, f| {

+ Box::pin(async move {

+ poise::builtins::register_globally(ctx, &f.options().commands).await?;

+ println!("registered");

+ Ok(())

+ })

+ })

+ .build();

+ ClientBuilder::new(

+ tok,

+ GatewayIntents::non_privileged() | GatewayIntents::MESSAGE_CONTENT,

+ )

+ .framework(f)

+ .await

+ .unwrap()

+ .start()

+ .await

+ .unwrap();

+ }

+}

+type Context<'a> = poise::Context<'a, (), anyhow::Error>;

+

+async fn on_error(error: poise::FrameworkError<'_, (), anyhow::Error>) {

+ use poise::FrameworkError::Command;

+ match error {

+ Command { error, ctx, .. } => {

+ ctx.say(format!("<@696196765564534825> {error}"))

+ .await

+ .unwrap();

+ }

+ err => poise::builtins::on_error(err).await.unwrap(),

+ }

+}

+

+#[poise::command(slash_command)]

+/// ask for information

+pub async fn help(ctx: Context<'_>) -> Result<()> {

+ ctx.send(

+ poise::CreateReply::default()

+ .ephemeral(true)

+ .content(include_str!("help.md")),

+ )

+ .await?;

+ Ok(())

+}

+const OWNER: u64 = 696196765564534825;

+#[poise::command(slash_command)]

+/// Run the logger

+pub async fn run(c: Context<'_>) -> Result<()> {

+ if c.author().id != OWNER {

+ poise::say_reply(c, "access denied. this incident will be reported").await?;

+ return Ok(());

+ }

+ poise::say_reply(c, OK).await?;

+ tokio::spawn(lop(c.serenity_context().clone()));

+ Ok(())

+}

+

+#[poise::command(slash_command)]

+/// Prune own messages.

+pub async fn prune(c: Context<'_>) -> Result<()> {

+ if c.author().id != OWNER {

+ poise::say_reply(c, "access denied. this incident will be reported").await?;

+ return Ok(());

+ }

+ let h = poise::say_reply(c, "working...").await?;

+ let hm = h.message().await.unwrap().id;

+ let g = c.http().get_guild(925674713429184564.into()).await.unwrap();

+ let ch = g.channel_id_from_name(c, "server-logs").unwrap();

+ let mut strm = pin!(ch.messages_iter(c));

+ while let Some(Ok(next)) = futures::StreamExt::next(&mut strm).await {

+ if next.id == hm {

+ continue;

+ }

+ if next.is_own(c) {

+ next.delete(c).await?;

+ }

+ }

+ h.edit(c, CreateReply::default().content(OK)).await?;

+ std::fs::write("last", &[b'0']).unwrap();

+ Ok(())

+}

+

+#[tokio::main(flavor = "current_thread")]

+async fn main() {

+ Bot::spawn().await;

+}