Member listeners and automod rule fixes

benthetechguy · benthetechguy · commit c60b20d32c1a · 2025-07-07T23:35:55.000-04:00
diff --git a/config.json b/config.json
@@ -27,6 +27,7 @@
     "vc_chat": 854429524657176601
   },
   "log_channel_ids": {
+    "welcome": 854429524477476864,
     "suggestion_list": 854429524798996483,
     "tickets": 854429524798996480,
     "staff_news": 854429525147385895,
diff --git a/src/command_modules/moderation.cpp b/src/command_modules/moderation.cpp
@@ -175,7 +175,7 @@ dpp::task<> moderation::inviteinfo(const dpp::slashcommand_t &event) {
     if (invite.expires_at == 0) {
         embed.add_field("Expires", "Never", false);
     } else {
-        embed.add_field("Expires", std::format("<t:{}>", invite.expires_at), false);
+        embed.add_field("Expires", std::format("<t:{}:R>", invite.expires_at), false);
     }
     co_await thinking;
     event.edit_original_response(dpp::message(embed));
diff --git a/src/listeners/automod_rules.cpp b/src/listeners/automod_rules.cpp
@@ -130,8 +130,8 @@ void automod_rules::add_rule_description_fields(dpp::embed& embed, const dpp::au
     }
 }
 
-dpp::task<> automod_rules::on_automod_rule_add(const dpp::automod_rule_create_t &event, const nlohmann::json& config) {
-    util::AUTOMOD_RULE_CACHE.push(event.created);
+dpp::task<> automod_rules::on_automod_rule_add(const dpp::automod_rule_create_t &event, const nlohmann::json& config, std::vector<dpp::automod_rule>& automod_rules) {
+    automod_rules.push_back(event.created);
     dpp::confirmation_callback_t user_conf = co_await event.owner->co_user_get_cached(event.created.creator_id);
     dpp::user_identified user;
     if (user_conf.is_error()) {
@@ -147,22 +147,26 @@ dpp::task<> automod_rules::on_automod_rule_add(const dpp::automod_rule_create_t
     event.owner->message_create(dpp::message(config["log_channel_ids"]["discord_updates"], embed));
 }
 
-void automod_rules::on_automod_rule_remove(const dpp::automod_rule_delete_t &event, const nlohmann::json& config) {
+void automod_rules::on_automod_rule_remove(const dpp::automod_rule_delete_t &event, const nlohmann::json& config, std::vector<dpp::automod_rule>& automod_rules) {
     dpp::embed embed = dpp::embed().set_color(dpp::colors::red).set_title("Automod Rule Deleted")
                                    .add_field("Rule Name", event.deleted.name, true);
     add_rule_description_fields(embed, event.deleted);
     event.owner->message_create(dpp::message(config["log_channel_ids"]["discord_updates"], embed));
+    // Delete rule from cache if possible
+    if (const auto it = std::ranges::find(automod_rules, event.deleted); it != automod_rules.end()) {
+        automod_rules.erase(it);
+    }
 }
 
-void automod_rules::on_automod_rule_edit(const dpp::automod_rule_update_t &event, const nlohmann::json& config) {
+void automod_rules::on_automod_rule_edit(const dpp::automod_rule_update_t &event, const nlohmann::json& config, std::vector<dpp::automod_rule>& automod_rules) {
     dpp::embed embed = dpp::embed().set_color(0x00A0A0).set_title("Automod Rule Edited")
-                                   .add_field("Rule Name", event.updated.name, true);
+                                   .add_field("Rule Name", event.updated.name, false);
     // Find rule in cache
-    auto old_rule = util::AUTOMOD_RULE_CACHE.begin();
-    while (old_rule != util::AUTOMOD_RULE_CACHE.end() && old_rule->id != event.updated.id) ++old_rule;
+    auto old_rule = automod_rules.begin();
+    while (old_rule != automod_rules.end() && old_rule->id != event.updated.id) ++old_rule;
     // If rule cannot be found, add edited version to cache and exit
-    if (old_rule == util::AUTOMOD_RULE_CACHE.end()) {
-        util::AUTOMOD_RULE_CACHE.push(event.updated);
+    if (old_rule == automod_rules.end()) {
+        automod_rules.push_back(event.updated);
         embed.set_footer(dpp::embed_footer().set_text("Limited info available (old rule not in cache)"));
         event.owner->message_create(dpp::message(config["log_channel_ids"]["discord_updates"], embed));
         return;
@@ -403,8 +407,8 @@ void automod_rules::on_automod_rule_edit(const dpp::automod_rule_update_t &event
     if (new_actions != old_actions) {
         old_actions.pop_back();
         new_actions.pop_back();
-        embed.add_field("Old list of actions to take", old_actions, false);
-        embed.add_field("New list of actions to take", new_actions, false);
+        embed.add_field("Old list of actions to take", old_actions, true);
+        embed.add_field("New list of actions to take", new_actions, true);
     }
 
     if (event.updated.enabled != old_rule->enabled) {
diff --git a/src/listeners/automod_rules.h b/src/listeners/automod_rules.h
@@ -17,7 +17,7 @@
 
 namespace automod_rules {
     void add_rule_description_fields(dpp::embed& embed, const dpp::automod_rule& rule);
-    dpp::task<> on_automod_rule_add(const dpp::automod_rule_create_t &event, const nlohmann::json& config);
-    void on_automod_rule_remove(const dpp::automod_rule_delete_t &event, const nlohmann::json& config);
-    void on_automod_rule_edit(const dpp::automod_rule_update_t &event, const nlohmann::json& config);
+    dpp::task<> on_automod_rule_add(const dpp::automod_rule_create_t &event, const nlohmann::json& config, std::vector<dpp::automod_rule>& automod_rules);
+    void on_automod_rule_remove(const dpp::automod_rule_delete_t &event, const nlohmann::json& config, std::vector<dpp::automod_rule>& automod_rules);
+    void on_automod_rule_edit(const dpp::automod_rule_update_t &event, const nlohmann::json& config, std::vector<dpp::automod_rule>& automod_rules);
 }
diff --git a/src/listeners/guild.cpp b/src/listeners/guild.cpp
@@ -0,0 +1,54 @@
+/* guild: Handlers for events related to the guild
+ * Copyright 2025 Ben Westover <me@benthetechguy.net>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option)
+ * any later version. This program is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+#include "guild.h"
+#include "../util.h"
+
+void guild::on_invite_created(const dpp::invite_create_t &event, const nlohmann::json& config, std::vector<dpp::invite>& invites) {
+    invites.push_back(event.created_invite);
+
+    dpp::embed embed = dpp::embed().set_color(dpp::colors::green).set_thumbnail(event.created_invite.inviter.get_avatar_url())
+                                   .set_title("Invite Created")
+                                   .add_field("Invite Creator", event.created_invite.inviter.username, true)
+                                   .add_field("User ID", event.created_invite.inviter.id.str(), true)
+                                   .add_field("Invite Code", event.created_invite.code, false)
+                                   .add_field("Invite Channel", event.created_invite.destination_channel.get_mention(), true);
+    if (event.created_invite.expires_at == 0) {
+        embed.add_field("Expires", "Never", true);
+    } else {
+        embed.add_field("Expires", std::format("<t:{}:R>", event.created_invite.expires_at), true);
+    }
+    event.owner->message_create(dpp::message(config["log_channel_ids"]["invites"], embed));
+}
+
+void guild::on_invite_deleted(const dpp::invite_delete_t &event, const nlohmann::json& config, std::vector<dpp::invite>& invites) {
+
+    dpp::embed embed = dpp::embed().set_color(dpp::colors::red).set_title("Invite Deleted");
+    // Find invite in cache
+    auto invite = invites.begin();
+    while (invite != invites.end() && invite->code != event.deleted_invite.code) ++invite;
+    if (invite == invites.end()) {
+        embed.add_field("Invite Code", event.deleted_invite.code, false);
+        embed.set_footer(dpp::embed_footer().set_text("Invite not found in cache; limited info available."));
+    } else {
+        embed.add_field("Invite Creator", invite->inviter.username, true)
+             .add_field("User ID", invite->inviter.id.str(), true)
+             .add_field("Invite Code", invite->code, false)
+             .add_field("Invite Channel", invite->destination_channel.get_mention(), true)
+             .add_field("Uses", std::to_string(invite->uses), true);
+        // Delete invite from cache
+        invites.erase(invite);
+    }
+    event.owner->message_create(dpp::message(config["log_channel_ids"]["invites"], embed));
+}
diff --git a/src/listeners/guild.h b/src/listeners/guild.h
@@ -0,0 +1,21 @@
+/* guild: Handlers for events related to the guild
+ * Copyright 2025 Ben Westover <me@benthetechguy.net>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option)
+ * any later version. This program is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <dpp/dpp.h>
+
+namespace guild {
+    void on_invite_created(const dpp::invite_create_t &event, const nlohmann::json& config, std::vector<dpp::invite>& invites);
+    void on_invite_deleted(const dpp::invite_delete_t &event, const nlohmann::json& config, std::vector<dpp::invite>& invites);
+}
diff --git a/src/listeners/members.cpp b/src/listeners/members.cpp
@@ -0,0 +1,145 @@
+/* members: Handlers for events involving server members
+ * Copyright 2025 Ben Westover <me@benthetechguy.net>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option)
+ * any later version. This program is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+#include "members.h"
+#include "../util.h"
+
+dpp::task<dpp::invite> members::findinvite(dpp::cluster* bot, const dpp::snowflake guild, std::vector<dpp::invite>& invites) {
+    dpp::invite invite_used = dpp::invite();
+    invite_used.code = "unknown";
+
+    // Get current invite list
+    dpp::confirmation_callback_t invites_conf = co_await bot->co_guild_get_invites(guild);
+    if (invites_conf.is_error()) {
+        co_return invite_used;
+    }
+    // Look for any invite with more uses than the cache has
+    for (size_t i = 0; i < invites.size(); i++) {
+        for (const dpp::invite& invite : std::get<dpp::invite_map>(invites_conf.value) | std::views::values) {
+            if (invite.code == invites[i].code && invite.uses > invites[i].uses) {
+                // Update invite in cache
+                invites[i] = invite;
+
+                invite_used = invite;
+                co_return invite_used;
+            }
+        }
+    }
+    co_return invite_used;
+}
+
+dpp::task<> members::on_kick(const dpp::guild_audit_log_entry_create_t& event, const nlohmann::json& config) {
+    dpp::confirmation_callback_t user_conf = co_await event.owner->co_user_get_cached(event.entry.target_id);
+    dpp::confirmation_callback_t mod_conf = co_await event.owner->co_user_get_cached(event.entry.user_id);
+
+    dpp::embed embed = dpp::embed().set_color(dpp::colors::red).set_title("Manual Kick");
+    if (!user_conf.is_error()) {
+        dpp::user_identified user = std::get<dpp::user_identified>(user_conf.value);
+        embed.set_thumbnail(user.get_avatar_url()).add_field("User kicked", user.username, true);
+    }
+    embed.add_field("User ID", event.entry.target_id.str(), true);
+
+    if (mod_conf.is_error()) {
+        embed.add_field("Moderator ID", event.entry.user_id.str(), false);
+    } else {
+        dpp::user_identified mod = std::get<dpp::user_identified>(mod_conf.value);
+        embed.add_field("Kicked by", mod.global_name, false);
+    }
+
+    if (!event.entry.reason.empty()) {
+        embed.add_field("Reason", event.entry.reason, false);
+    }
+    event.owner->message_create(dpp::message(config["log_channel_ids"]["mod_log"], embed));
+}
+
+dpp::task<> members::on_ban(const dpp::guild_audit_log_entry_create_t& event, const nlohmann::json& config) {
+    dpp::confirmation_callback_t user_conf = co_await event.owner->co_user_get_cached(event.entry.target_id);
+    dpp::confirmation_callback_t mod_conf = co_await event.owner->co_user_get_cached(event.entry.user_id);
+
+    dpp::embed embed = dpp::embed().set_color(dpp::colors::red).set_title("Manual Ban");
+    if (!user_conf.is_error()) {
+        dpp::user_identified user = std::get<dpp::user_identified>(user_conf.value);
+        embed.set_thumbnail(user.get_avatar_url()).add_field("User banned", user.username, true);
+    }
+    embed.add_field("User ID", event.entry.target_id.str(), true);
+
+    if (mod_conf.is_error()) {
+        embed.add_field("Moderator ID", event.entry.user_id.str(), false);
+    } else {
+        dpp::user_identified mod = std::get<dpp::user_identified>(mod_conf.value);
+        embed.add_field("Banned by", mod.global_name, false);
+    }
+
+    if (!event.entry.reason.empty()) {
+        embed.add_field("Reason", event.entry.reason, false);
+    }
+    event.owner->message_create(dpp::message(config["log_channel_ids"]["mod_log"], embed));
+}
+
+dpp::task<> members::on_unban(const dpp::guild_audit_log_entry_create_t& event, const nlohmann::json& config) {
+    dpp::confirmation_callback_t user_conf = co_await event.owner->co_user_get_cached(event.entry.target_id);
+    dpp::confirmation_callback_t mod_conf = co_await event.owner->co_user_get_cached(event.entry.user_id);
+
+    dpp::embed embed = dpp::embed().set_color(dpp::colors::green).set_title("Ban Manually Removed");
+    if (!user_conf.is_error()) {
+        dpp::user_identified user = std::get<dpp::user_identified>(user_conf.value);
+        embed.set_thumbnail(user.get_avatar_url()).add_field("User unbanned", user.username, true);
+    }
+    embed.add_field("User ID", event.entry.target_id.str(), true);
+
+    if (mod_conf.is_error()) {
+        embed.add_field("Moderator ID", event.entry.user_id.str(), false);
+    } else {
+        dpp::user_identified mod = std::get<dpp::user_identified>(mod_conf.value);
+        embed.add_field("Ban removed by", mod.global_name, false);
+    }
+
+    if (!event.entry.reason.empty()) {
+        embed.add_field("Reason", event.entry.reason, false);
+    }
+    event.owner->message_create(dpp::message(config["log_channel_ids"]["mod_log"], embed));
+}
+
+dpp::task<> members::on_join(const dpp::guild_member_add_t& event, const nlohmann::json& config, std::vector<dpp::invite>& invites) {
+    dpp::embed welcome_embed = dpp::embed().set_color(dpp::colors::green).set_title("New Member")
+                                           .set_thumbnail(event.added.get_user()->get_avatar_url())
+                                           .set_description(event.added.get_user()->global_name + " has joined Tech Support Central!");
+    event.owner->message_create(dpp::message(config["log_channel_ids"]["welcome"], welcome_embed));
+
+    dpp::embed log_embed = dpp::embed().set_color(dpp::colors::green).set_title("Member Joined")
+                                       .set_thumbnail(event.added.get_user()->get_avatar_url())
+                                       .set_description(event.added.get_user()->username)
+                                       .add_field("User ID", event.added.user_id.str(), false)
+                                       .add_field("Account Created:", std::format("<t:{}>",
+                                                  static_cast<time_t>(event.added.get_user()->get_creation_time())), false);
+    dpp::invite invite_used = co_await findinvite(event.owner, event.adding_guild.id, invites);
+    if (invite_used.code != "unknown") {
+        log_embed.add_field("Invite code", invite_used.code, false);
+        if (invite_used.code == "2vwUBmhM8U") {
+            log_embed.add_field("Invite creator", "top.gg", true);
+        } else {
+            log_embed.add_field("Invite creator", invite_used.inviter.username, true);
+        }
+        log_embed.add_field("Invite uses", std::to_string(invite_used.uses), true);
+    }
+    event.owner->message_create(dpp::message(config["log_channel_ids"]["member_log"], log_embed));
+}
+
+void members::on_leave(const dpp::guild_member_remove_t& event, const nlohmann::json& config) {
+    dpp::embed embed = dpp::embed().set_color(dpp::colors::red).set_title("Member Left")
+                                   .set_thumbnail(event.removed.get_avatar_url())
+                                   .set_description(event.removed.username + " has left Tech Support Central.")
+                                   .set_footer(dpp::embed_footer().set_text(std::string("User ID: ") + event.removed.id.str()));
+    event.owner->message_create(dpp::message(config["log_channel_ids"]["member_log"], embed));
+}
diff --git a/src/listeners/members.h b/src/listeners/members.h
@@ -0,0 +1,33 @@
+/* members: Handlers for events involving server members
+ * Copyright 2025 Ben Westover <me@benthetechguy.net>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option)
+ * any later version. This program is distributed in the hope that it will be
+ * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+#pragma once
+#include <dpp/dpp.h>
+
+namespace members {
+    /**
+     * Find the most recent invite used.
+     * @param bot Bot cluster to use to query guild invites
+     * @param guild Guild to search invites of
+     * @param invites List of invites to this guild (before the most recent invite use)
+     * @return The most recently used invite, or an empty invite with code "unknown"
+     */
+    dpp::task<dpp::invite> findinvite(dpp::cluster* bot, dpp::snowflake guild, std::vector<dpp::invite>& invites);
+
+    dpp::task<> on_kick(const dpp::guild_audit_log_entry_create_t& event, const nlohmann::json& config);
+    dpp::task<> on_ban(const dpp::guild_audit_log_entry_create_t& event, const nlohmann::json& config);
+    dpp::task<> on_unban(const dpp::guild_audit_log_entry_create_t& event, const nlohmann::json& config);
+    dpp::task<> on_join(const dpp::guild_member_add_t& event, const nlohmann::json& config, std::vector<dpp::invite>& invites);
+    void on_leave(const dpp::guild_member_remove_t& event, const nlohmann::json& config);
+}
diff --git a/src/main.cpp b/src/main.cpp
diff --git a/src/util.h b/src/util.h

Original file line number	Diff line number	Diff line change
`@@ -175,7 +175,7 @@ dpp::task<> moderation::inviteinfo(const dpp::slashcommand_t &event) {`
`175`	`175`	`if (invite.expires_at == 0) {`
`176`	`176`	`embed.add_field("Expires", "Never", false);`
`177`	`177`	`} else {`
`178`		`- embed.add_field("Expires", std::format("<t:{}>", invite.expires_at), false);`
	`178`	`+ embed.add_field("Expires", std::format("<t:{}:R>", invite.expires_at), false);`
`179`	`179`	`}`
`180`	`180`	`co_await thinking;`
`181`	`181`	`event.edit_original_response(dpp::message(embed));`