Merge branch 'main' of github.com:ketsuna-org/bot-creator-api into 1-more-actions-to-handle

1 files changed, 61 insertions, 61 deletions

diff --git a/bot/src/actions/delete.cpp b/bot/src/actions/delete.cpp
index 58835cf..5813d63 100644
--- a/bot/src/actions/delete.cpp
+++ b/bot/src/actions/delete.cpp
@@ -1,107 +1,107 @@
 #include <dpp/dpp.h>
 
-dpp::task<bool> delete_action(const dpp::slashcommand_t &event, const nlohmann::json &action, const std::unordered_map<std::string, std::string> &key_values, dpp::user &user_ptr, dpp::cluster *cluster)
+dpp::task<bool> delete_action(const dpp::slashcommand_t &event, const nlohmann::json &action,
+                              const std::unordered_map<std::string, std::string> &key_values,
+                              dpp::user &user_ptr, dpp::cluster *cluster)
 {
-    dpp::guild guild_ptr = event.command.get_guild();
-    // let's retrieve the member.
-    dpp::guild_member member_ptr = guild_ptr.members.find(user_ptr.id)->second;
-    dpp::guild_member bot_member_ptr = guild_ptr.members.find(cluster->me.id)->second;
-    std::unordered_map<std::string, std::string> error_messages = {
-        {"error", "You need to wait a bit before deleting messages."},
-        {"error_amount", "The amount of messages to delete must be between 1 and 100."},
-        {"error_perm_channel", "You do not have permission to delete messages in this channel."}};
+    const dpp::channel *channel_ptr = &event.command.get_channel();
+    const auto &guild_ptr = event.command.get_guild();
 
-    if (action.contains("error_amount"))
-    {
-        error_messages["error_amount"] = action["error_amount"].get<std::string>();
-    }
+    const auto member_it = guild_ptr.members.find(user_ptr.id);
+    const auto *member_ptr = (member_it != guild_ptr.members.end()) ? &member_it->second : nullptr;
 
-    if (action.contains("error_perm_channel"))
-    {
-        error_messages["error_perm_channel"] = action["error_perm_channel"].get<std::string>();
-    }
+    const auto bot_member_it = guild_ptr.members.find(cluster->me.id);
+    const auto *bot_member_ptr = (bot_member_it != guild_ptr.members.end()) ? &bot_member_it->second : nullptr;
 
-    if (action.contains("error"))
+    const std::unordered_map<std::string, std::string> error_messages = [&action]()
     {
-        error_messages["error"] = action["error"].get<std::string>();
-    }
-    // let's retrieve the current channel
-    const dpp::channel *channel_ptr = &event.command.get_channel();
-    auto user_as_perms = channel_ptr->get_user_permissions(member_ptr).has(dpp::p_manage_messages);
-    auto bot_as_perms = channel_ptr->get_user_permissions(bot_member_ptr).has(dpp::p_manage_messages);
-    if (!user_as_perms)
+        std::unordered_map<std::string, std::string> defaults = {
+            {"error", "You need to wait a bit before deleting messages."},
+            {"error_amount", "The amount of messages to delete must be between 1 and 100."},
+            {"error_perm_channel", "You do not have permission to delete messages in this channel."}};
+        if (action.contains("error_amount"))
+            defaults["error_amount"] = action["error_amount"];
+        if (action.contains("error_perm_channel"))
+            defaults["error_perm_channel"] = action["error_perm_channel"];
+        if (action.contains("error"))
+            defaults["error"] = action["error"];
+        return defaults;
+    }();
+
+    if (!member_ptr || !bot_member_ptr)
     {
-        event.edit_response(error_messages["error_perm_channel"]);
+        event.edit_response(error_messages.at("error_perm_channel"));
         co_return false;
     }
-    if (!bot_as_perms)
+
+    const bool has_permissions = channel_ptr->get_user_permissions(*member_ptr).has(dpp::p_manage_messages) && channel_ptr->get_user_permissions(*bot_member_ptr).has(dpp::p_manage_messages);
+    if (!has_permissions)
     {
-        event.edit_response(error_messages["error_perm_channel"]);
+        event.edit_response(error_messages.at("error_perm_channel"));
         co_return false;
     }
+
     int amount = 0;
     if (action.contains("depend_on"))
     {
-        std::string depend_on = action["depend_on"];
-        auto it = key_values.find(depend_on);
-        if (it != key_values.end())
+        const std::string &depend_on = action["depend_on"];
+        if (const auto it = key_values.find(depend_on); it != key_values.end())
         {
-            std::string depend_on_value = it->second;
-
-            // let's convert the depend_on_value to an int
-            amount = std::stoi(depend_on_value);
-            if (amount < 0 || amount > 100)
+            try
+            {
+                amount = std::stoi(it->second);
+                if (amount < 1 || amount > 100)
+                {
+                    event.edit_response(error_messages.at("error_amount"));
+                    co_return false;
+                }
+            }
+            catch (const std::exception &e)
             {
-                event.edit_response(error_messages["error_amount"]);
+                event.edit_response(error_messages.at("error"));
                 co_return false;
             }
         }
     }
+
     if (amount > 0)
     {
-        dpp::confirmation_callback_t callback = co_await cluster->co_messages_get(channel_ptr->id, 0, 0, 0, amount);
+        const time_t two_weeks_ago = dpp::utility::time_f() - 1209600;
+
+        auto callback = co_await cluster->co_messages_get(channel_ptr->id, 0, 0, 0, amount);
         if (callback.is_error())
         {
-            printf("Error: %s\n", callback.get_error().message.c_str());
-            event.edit_response(error_messages["error"]);
+            event.edit_response(error_messages.at("error"));
             co_return false;
         }
-        auto messages = callback.get<dpp::message_map>();
+
+        const auto &messages = callback.get<dpp::message_map>();
         if (messages.empty())
         {
             event.edit_response("No messages to delete.");
             co_return false;
         }
+
         std::vector<dpp::snowflake> msg_ids;
+        msg_ids.reserve(messages.size());
 
-        for (const auto &msg : messages)
+        for (const auto &[id, msg] : messages)
         {
-            // let's check if the message is older than 2 weeks
-            if (msg.second.get_creation_time() < dpp::utility::time_f() - 1209600)
-            {
-                printf("Message is older than 2 weeks\n");
-                continue;
-            }
-            else
+            if (msg.get_creation_time() >= two_weeks_ago)
             {
-                msg_ids.push_back(msg.second.id);
+                msg_ids.emplace_back(id);
             }
         }
 
         if (!msg_ids.empty())
         {
-            dpp::confirmation_callback_t result;
-            if (msg_ids.size() == 1)
-            {
-                result = co_await cluster->co_message_delete(msg_ids[0], channel_ptr->id);
-            }
-            else
-            {
-                result = co_await cluster->co_message_delete_bulk(msg_ids, channel_ptr->id);
-            }
-            if (result.is_error())
+            const auto delete_result = msg_ids.size() == 1
+                                           ? co_await cluster->co_message_delete(msg_ids.front(), channel_ptr->id)
+                                           : co_await cluster->co_message_delete_bulk(msg_ids, channel_ptr->id);
+
+            if (delete_result.is_error())
             {
-                event.edit_response(error_messages["error"]);
+                event.edit_response(error_messages.at("error"));
                 co_return false;
             }
         }