From a26763df96ebd77becd21385090b0ed462ebbdd9 Mon Sep 17 00:00:00 2001 From: Syping Date: Wed, 7 Feb 2024 19:30:46 +0100 Subject: [PATCH] basic impl of database system --- src/database_core.cpp | 33 +- src/database_core.h | 13 +- src/database_file.cpp | 497 ++++++++++++++++++++++++++++-- src/database_file.h | 16 +- src/slashcommands.cpp | 14 +- src/translator_libretranslate.cpp | 6 +- src/webhook_push.cpp | 3 +- 7 files changed, 539 insertions(+), 43 deletions(-) diff --git a/src/database_core.cpp b/src/database_core.cpp index 8c66c8b..ca5a33b 100644 --- a/src/database_core.cpp +++ b/src/database_core.cpp @@ -30,12 +30,32 @@ database::~database() { } -bool database::add_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const bot::settings::target &target) +void database::add_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const bot::settings::target &target) { #ifndef NDEBUG std::cerr << "[Debug] database::add_channel_target(dpp::snowflake, dpp::snowflake, const bot::settings::target&) have being called." << std::endl; #endif - return false; +} + +void database::delete_channel(dpp::snowflake guild_id, dpp::snowflake channel_id) +{ +#ifndef NDEBUG + std::cerr << "[Debug] database::delete_channel(dpp::snowflake, dpp::snowflake) have being called." << std::endl; +#endif +} + +void database::delete_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &target) +{ +#ifndef NDEBUG + std::cerr << "[Debug] database::delete_channel_target(dpp::snowflake, dpp::snowflake, const std::string&) have being called." << std::endl; +#endif +} + +void database::delete_guild(dpp::snowflake guild_id) +{ +#ifndef NDEBUG + std::cerr << "[Debug] database::delete_guild(dpp::snowflake) have being called." << std::endl; +#endif } std::variant database::find_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &target) @@ -78,10 +98,17 @@ std::vector database::get_guilds() return {}; } -bool database::set_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &source) +void database::set_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &source) { #ifndef NDEBUG std::cerr << "[Debug] database::set_channel_source(dpp::snowflake, dpp::snowflake, const std::string&) have being called." << std::endl; +#endif +} + +bool database::sync() +{ +#ifndef NDEBUG + std::cerr << "[Debug] database::sync() have being called." << std::endl; #endif return false; } diff --git a/src/database_core.h b/src/database_core.h index 4971b72..52700ab 100644 --- a/src/database_core.h +++ b/src/database_core.h @@ -23,17 +23,26 @@ namespace bot { namespace database { + struct guild { + dpp::snowflake id; + std::vector channel; + }; + class database { public: explicit database(); virtual ~database(); - virtual bool add_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const bot::settings::target &target); + virtual void add_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const bot::settings::target &target); + virtual void delete_channel(dpp::snowflake guild_id, dpp::snowflake channel_id); + virtual void delete_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &target); + virtual void delete_guild(dpp::snowflake guild_id); virtual std::variant find_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &target); virtual std::vector get_channels(dpp::snowflake guild_id); virtual std::string get_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id); virtual std::vector get_channel_targets(dpp::snowflake guild_id, dpp::snowflake channel_id); virtual std::vector get_guilds(); - virtual bool set_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &source); + virtual void set_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &source); + virtual bool sync(); }; } } diff --git a/src/database_file.cpp b/src/database_file.cpp index 227d12f..cd73853 100644 --- a/src/database_file.cpp +++ b/src/database_file.cpp @@ -21,14 +21,21 @@ #include #include #endif +#include +#include +#include +#include +#include #include +#include #include "database_file.h" using namespace bot::database; +using namespace std::string_literals; file::file(const std::filesystem::path &storage_path) : m_storagePath(storage_path) { std::cout << "[Launch] Checking storage directory..." << std::endl; - if (!std::filesystem::exists(storage_path)) { + if (!std::filesystem::is_directory(storage_path)) { std::cerr << "[Error] Storage directory " << storage_path << " can not be found" << std::endl; throw std::runtime_error("Storage directory can not be found"); } @@ -57,63 +64,493 @@ file::file(const std::filesystem::path &storage_path) : m_storagePath(storage_pa file::~file() { + const std::lock_guard guard(m_mutex); #ifdef __unix__ close(fd); #endif } -bool file::add_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const bot::settings::target &target) +void file::add_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const bot::settings::target &target) { -#ifndef NDEBUG - std::cerr << "[Debug] database::add_channel_target(dpp::snowflake, dpp::snowflake, const bot::settings::target&) have being called." << std::endl; -#endif - return false; + const std::lock_guard guard(m_mutex); + for (auto guild = m_dataCache.begin(); guild != m_dataCache.end(); guild++) { + if (guild->id == guild_id) { + for (auto channel = guild->channel.begin(); channel != guild->channel.end(); channel++) { + if (channel->id == channel_id) { + for (auto _target = channel->targets.begin(); _target != channel->targets.end(); _target++) { + if (_target->target == target.target) { + _target->webhook = target.webhook; + return; + } + } + + channel->targets.push_back(target); + return; + } + } + + bot::settings::channel channel; + cache_channel(channel_id, &channel); + channel.targets.push_back(target); + guild->channel.push_back(std::move(channel)); + cache_add_channel(guild_id, channel_id); + return; + } + } + + bot::settings::channel channel; + cache_channel(channel_id, &channel); + channel.targets.push_back(target); + + bot::settings::guild guild; + guild.id = guild_id; + guild.channel.push_back(std::move(channel)); + cache_add_channel(guild_id, channel_id); + + m_dataCache.push_back(std::move(guild)); +} + +void file::delete_channel(dpp::snowflake guild_id, dpp::snowflake channel_id) +{ + const std::lock_guard guard(m_mutex); + + for (auto guild = m_dataCache.begin(); guild != m_dataCache.end(); guild++) { + if (guild->id == guild_id) { + for (auto channel = guild->channel.begin(); channel != guild->channel.end(); channel++) { + if (channel->id == channel_id) { + guild->channel.erase(channel); + break; + } + } + break; + } + } + + for (auto guild = m_channelCache.begin(); guild != m_channelCache.end(); guild++) { + if (guild->id == guild_id) { + for (auto channel = guild->channel.begin(); channel != guild->channel.end(); channel++) { + if (*channel == channel_id) { + guild->channel.erase(channel); + break; + } + } + break; + } + + std::vector channels; + cache_guild(guild_id, &channels); + for (auto channel = channels.begin(); channel != channels.end(); channel++) { + if (*channel == channel_id) { + channels.erase(channel); + break; + } + } + + bot::database::guild _guild; + _guild.id = guild_id; + _guild.channel = std::move(channels); + m_channelCache.push_back(std::move(_guild)); + } + + const std::filesystem::path channel_file = m_storagePath / "channel" / (std::to_string(channel_id) + ".json"); + std::filesystem::remove(channel_file); +} + +void file::delete_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &target) +{ + const std::lock_guard guard(m_mutex); + + for (auto guild = m_dataCache.begin(); guild != m_dataCache.end(); guild++) { + if (guild->id == guild_id) { + for (auto channel = guild->channel.begin(); channel != guild->channel.end(); channel++) { + if (channel->id == channel_id) { + for (auto _target = channel->targets.begin(); _target != channel->targets.end(); _target++) { + if (_target->target == target) { + channel->targets.erase(_target); + return; + } + } + return; + } + } + + bot::settings::channel channel; + cache_channel(channel_id, &channel); + for (auto _target = channel.targets.begin(); _target != channel.targets.end(); _target++) { + if (_target->target == target) { + channel.targets.erase(_target); + guild->channel.push_back(std::move(channel)); + return; + } + } + return; + } + } + + bot::settings::channel channel; + cache_channel(channel_id, &channel); + for (auto _target = channel.targets.begin(); _target != channel.targets.end(); _target++) { + if (_target->target == target) { + channel.targets.erase(_target); + break; + } + } + + bot::settings::guild guild; + guild.id = guild_id; + guild.channel.push_back(std::move(channel)); + + m_dataCache.push_back(std::move(guild)); +} + +void file::delete_guild(dpp::snowflake guild_id) +{ + const std::lock_guard guard(m_mutex); + + for (auto guild = m_dataCache.begin(); guild != m_dataCache.end(); guild++) { + if (guild->id == guild_id) { + m_dataCache.erase(guild); + break; + } + } + + for (auto guild = m_channelCache.begin(); guild != m_channelCache.end(); guild++) { + if (guild->id == guild_id) { + m_channelCache.erase(guild); + break; + } + } + + const std::filesystem::path guild_file = m_storagePath / "guild" / (std::to_string(guild_id) + ".json"); + std::filesystem::remove(guild_file); } std::variant file::find_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &target) { -#ifndef NDEBUG - std::cerr << "[Debug] database::find_channel_target(dpp::snowflake, dpp::snowflake, const std::string&) have being called." << std::endl; -#endif + const std::lock_guard guard(m_mutex); + + for (auto guild = m_dataCache.begin(); guild != m_dataCache.end(); guild++) { + if (guild->id == guild_id) { + for (auto channel = guild->channel.begin(); channel != guild->channel.end(); channel++) { + if (channel->id == channel_id) { + for (auto _target = channel->targets.begin(); _target != channel->targets.end(); _target++) { + if (_target->target == target) + return *_target; + } + return {}; + } + } + } + } + + bot::settings::channel channel; + cache_channel(channel_id, &channel); + for (auto _target = channel.targets.begin(); _target != channel.targets.end(); _target++) { + if (_target->target == target) { + return *_target; + } + } return {}; } std::vector file::get_channels(dpp::snowflake guild_id) { -#ifndef NDEBUG - std::cerr << "[Debug] database::get_channels(dpp::snowflake) have being called." << std::endl; -#endif - return {}; + const std::lock_guard guard(m_mutex); + + for (auto guild = m_channelCache.begin(); guild != m_channelCache.end(); guild++) { + if (guild->id == guild_id) { + return guild->channel; + } + } + + std::vector channels; + cache_guild(guild_id, &channels); + return channels; } std::string file::get_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id) { -#ifndef NDEBUG - std::cerr << "[Debug] database::get_channel_source(dpp::snowflake, dpp::snowflake) have being called." << std::endl; -#endif - return {}; + const std::lock_guard guard(m_mutex); + + for (auto guild = m_dataCache.begin(); guild != m_dataCache.end(); guild++) { + if (guild->id == guild_id) { + for (auto channel = guild->channel.begin(); channel != guild->channel.end(); channel++) { + if (channel->id == channel_id) + return channel->source; + } + break; + } + } + + bot::settings::channel channel; + cache_channel(channel_id, &channel); + return channel.source; } std::vector file::get_channel_targets(dpp::snowflake guild_id, dpp::snowflake channel_id) { -#ifndef NDEBUG - std::cerr << "[Debug] database::get_channel_targets(dpp::snowflake, dpp::snowflake) have being called." << std::endl; -#endif - return {}; + const std::lock_guard guard(m_mutex); + + for (auto guild = m_dataCache.begin(); guild != m_dataCache.end(); guild++) { + if (guild->id == guild_id) { + for (auto channel = guild->channel.begin(); channel != guild->channel.end(); channel++) { + if (channel->id == channel_id) { + return channel->targets; + } + } + break; + } + } + + bot::settings::channel channel; + cache_channel(channel_id, &channel); + return channel.targets; } std::vector file::get_guilds() { -#ifndef NDEBUG - std::cerr << "[Debug] database::get_guilds() have being called." << std::endl; -#endif - return {}; + const std::lock_guard guard(m_mutex); + std::vector guilds; + list_guilds(&guilds); + return guilds; } -bool file::set_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &source) +void file::set_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &source) { -#ifndef NDEBUG - std::cerr << "[Debug] database::set_channel_source(dpp::snowflake, dpp::snowflake, const std::string&) have being called." << std::endl; -#endif - return false; + const std::lock_guard guard(m_mutex); + + for (auto guild = m_dataCache.begin(); guild != m_dataCache.end(); guild++) { + if (guild->id == guild_id) { + for (auto channel = guild->channel.begin(); channel != guild->channel.end(); channel++) { + if (channel->id == channel_id) { + channel->source = source; + return; + } + } + + bot::settings::channel channel; + cache_channel(channel_id, &channel); + channel.source = source; + guild->channel.push_back(std::move(channel)); + cache_add_channel(guild_id, channel_id); + return; + } + } + + bot::settings::channel channel; + cache_channel(channel_id, &channel); + channel.source = source; + + bot::settings::guild guild; + guild.id = guild_id; + guild.channel.push_back(std::move(channel)); + cache_add_channel(guild_id, channel_id); + + m_dataCache.push_back(std::move(guild)); +} + +bool file::sync() +{ + const std::lock_guard guard(m_mutex); + + const std::filesystem::path channel_dir = m_storagePath / "channel"; + bool channel_dir_exists = std::filesystem::is_directory(channel_dir); + if (!channel_dir_exists) + channel_dir_exists = std::filesystem::create_directory(channel_dir); + + if (channel_dir_exists) { + for (auto guild = m_dataCache.begin(); guild != m_dataCache.end(); guild++) { + for (auto channel = guild->channel.begin(); channel != guild->channel.end();) { + dpp::json target_json; + for (auto target = channel->targets.begin(); target != channel->targets.end(); target++) { + target_json[target->target] = { + std::to_string(target->webhook.id), target->webhook.token + }; + } + dpp::json channel_json = { + {"source"s, channel->source}, + {"target"s, target_json} + }; + + const std::filesystem::path channel_file = m_storagePath / "channel" / (std::to_string(channel->id) + ".json"); + std::ofstream ofs(channel_file, std::ios::out | std::ios::binary | std::ios::trunc); + if (ofs.is_open()) { + ofs << channel_json.dump(); + bool ok = ofs.good(); + ofs.close(); + if (ok) + channel = guild->channel.erase(channel); + else + channel++; + } + else + channel++; + } + } + } + else { + std::cerr << "[Error] Storage channel directory can not be created" << std::endl; + } + + const std::filesystem::path guild_dir = m_storagePath / "guild"; + bool guild_dir_exists = std::filesystem::is_directory(guild_dir); + if (!guild_dir_exists) + guild_dir_exists = std::filesystem::create_directory(guild_dir); + + if (guild_dir_exists) { + for (auto guild = m_channelCache.begin(); guild != m_channelCache.end();) { + dpp::json guild_json; + for (auto channel = guild->channel.begin(); channel != guild->channel.end(); channel++) + guild_json.push_back(std::to_string(*channel)); + + const std::filesystem::path guild_file = m_storagePath / "guild" / (std::to_string(guild->id) + ".json"); + std::ofstream ofs(guild_file, std::ios::out | std::ios::binary | std::ios::trunc); + if (ofs.is_open()) { + ofs << guild_json.dump(); + bool ok = ofs.good(); + ofs.close(); + if (ok) + guild = m_channelCache.erase(guild); + else + guild++; + } + else + guild++; + } + } + else { + std::cerr << "[Error] Storage guild directory can not be created" << std::endl; + } + + return true; +} + +void file::cache_add_channel(dpp::snowflake guild_id, dpp::snowflake channel_id) +{ + for (auto guild = m_channelCache.begin(); guild != m_channelCache.end(); guild++) { + if (guild->id == guild_id) { + if (std::find(guild->channel.begin(), guild->channel.end(), channel_id) == guild->channel.end()) + guild->channel.push_back(channel_id); + return; + } + } + + std::vector channels; + cache_guild(guild_id, &channels); + if (std::find(channels.begin(), channels.end(), channel_id) == channels.end()) + channels.push_back(channel_id); + + bot::database::guild guild; + guild.id = guild_id; + guild.channel = std::move(channels); + m_channelCache.push_back(std::move(guild)); +} + +void file::cache_channel(dpp::snowflake channel_id, bot::settings::channel *channel) +{ + channel->id = channel_id; + + const std::filesystem::path channel_file = m_storagePath / "channel" / (std::to_string(channel_id) + ".json"); + + if (!std::filesystem::is_regular_file(channel_file)) + return; + + std::ifstream ifs(channel_file, std::ios::in | std::ios::binary); + if (!ifs.is_open()) + return; + + std::string sdata(std::istreambuf_iterator{ifs}, {}); + ifs.close(); + + try { + const dpp::json json = dpp::json::parse(sdata); + if (json.is_object()) { + auto json_channel_source = json.find("source"); + if (json_channel_source != json.end()) + channel->source = *json_channel_source; + + auto json_channel_target = json.find("target"); + if (json_channel_target != json.end()) { + if (json_channel_target->is_object()) { + for (auto json_target = json_channel_target->begin(); json_target != json_channel_target->end(); json_target++) { + bot::settings::target target; + target.target = json_target.key(); + if (json_target->is_array()) { + if (json_target->size() == 2) { + target.webhook.id = std::stoull(std::string(json_target->front())); + target.webhook.token = json_target->back(); + } + } + else if (json_target->is_string()) { + target.webhook = dpp::webhook(*json_target); + } + channel->targets.push_back(std::move(target)); + } + } + } + } + } + catch (const std::exception &exception) { + std::cerr << "[Exception] " << exception.what() << std::endl; + } +} + +void file::cache_guild(dpp::snowflake guild_id, std::vector *channels) +{ + const std::filesystem::path guild_file = m_storagePath / "guild" / (std::to_string(guild_id) + ".json"); + + if (!std::filesystem::is_regular_file(guild_file)) + return; + + std::ifstream ifs(guild_file, std::ios::in | std::ios::binary); + if (!ifs.is_open()) + return; + + std::string sdata(std::istreambuf_iterator{ifs}, {}); + ifs.close(); + + try { + const dpp::json json = dpp::json::parse(sdata); + if (json.is_array()) { + for (auto channel = json.begin(); channel != json.end(); channel++) { + if (channel->is_number()) + channels->push_back(*channel); + else if (channel->is_string()) + channels->push_back(std::stoull(std::string(*channel))); + } + } + } + catch (const std::exception &exception) { + std::cerr << "[Exception] " << exception.what() << std::endl; + } +} + +void file::list_guilds(std::vector *guilds) +{ + const std::filesystem::path guild_dir = m_storagePath / "guild"; + + if (!std::filesystem::is_directory(guild_dir)) + return; + + for (const auto &guild_file : std::filesystem::directory_iterator(guild_dir)) { + const std::filesystem::path &guild_file_path = guild_file.path(); + if (guild_file_path.extension() == "json") { + const std::string &guild_filename = guild_file_path.filename(); + if (std::all_of(guild_filename.begin(), guild_filename.end(), ::isdigit)) { + try { + dpp::snowflake guild_id = std::stoull(guild_filename); + guilds->push_back(guild_id); + } + catch (const std::exception &exception) { + std::cerr << "[Exception] " << exception.what() << std::endl; + } + } + } + } +} + +void file::sync_exec_async() +{ + std::thread thread(&file::sync, this); + thread.detach(); } diff --git a/src/database_file.h b/src/database_file.h index 5409862..b2acb2b 100644 --- a/src/database_file.h +++ b/src/database_file.h @@ -29,18 +29,30 @@ namespace bot { public: explicit file(const std::filesystem::path &storage_path); ~file(); - bool add_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const bot::settings::target &target) override; + void add_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const bot::settings::target &target) override; + void delete_channel(dpp::snowflake guild_id, dpp::snowflake channel_id) override; + void delete_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &target) override; + void delete_guild(dpp::snowflake guild_id) override; std::variant find_channel_target(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &target) override; std::vector get_channels(dpp::snowflake guild_id) override; std::string get_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id) override; std::vector get_channel_targets(dpp::snowflake guild_id, dpp::snowflake channel_id) override; std::vector get_guilds() override; - bool set_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &source) override; + void set_channel_source(dpp::snowflake guild_id, dpp::snowflake channel_id, const std::string &source) override; + bool sync() override; private: + void cache_add_channel(dpp::snowflake guild_id, dpp::snowflake channel_id); + void cache_delete_channel(dpp::snowflake guild_id, dpp::snowflake channel_id); + void cache_channel(dpp::snowflake channel_id, bot::settings::channel *channel); + void cache_guild(dpp::snowflake guild_id, std::vector *channels); + void list_guilds(std::vector *guilds); + void sync_exec_async(); #ifdef __unix__ int fd; #endif + std::vector m_channelCache; + std::vector m_dataCache; std::mutex m_mutex; std::filesystem::path m_storagePath; }; diff --git a/src/slashcommands.cpp b/src/slashcommands.cpp index 26d7cbc..f7885ac 100644 --- a/src/slashcommands.cpp +++ b/src/slashcommands.cpp @@ -79,13 +79,18 @@ void bot::slashcommands::process_translate_command(dpp::cluster *bot, bot::setti bot::settings::target s_target; s_target.target = target; s_target.webhook = webhook; - s_channel.targets.push_back(std::move(s_target)); + s_channel.targets.push_back(s_target); settings->lock(); settings->add_channel(s_channel, event.command.guild_id); settings->add_translatebot_webhook(webhook.id); + auto database = settings->get_database(); settings->unlock(); + database->set_channel_source(event.command.guild_id, event.command.channel_id, source); + database->add_channel_target(event.command.guild_id, event.command.channel_id, s_target); + database->sync(); // do async later + event.reply(dpp::message("Channel will be now translated!").set_flags(dpp::m_ephemeral)); }); } @@ -97,13 +102,18 @@ void bot::slashcommands::process_translate_command(dpp::cluster *bot, bot::setti bot::settings::target s_target; s_target.target = target; s_target.webhook = *webhook; - s_channel.targets.push_back(std::move(s_target)); + s_channel.targets.push_back(s_target); settings->lock(); settings->add_channel(s_channel, event.command.guild_id); settings->add_translatebot_webhook(webhook->id); + auto database = settings->get_database(); settings->unlock(); + database->set_channel_source(event.command.guild_id, event.command.channel_id, source); + database->add_channel_target(event.command.guild_id, event.command.channel_id, s_target); + database->sync(); // do async later + event.reply(dpp::message("Channel will be now translated!").set_flags(dpp::m_ephemeral)); } } diff --git a/src/translator_libretranslate.cpp b/src/translator_libretranslate.cpp index 14995dd..78a0026 100644 --- a/src/translator_libretranslate.cpp +++ b/src/translator_libretranslate.cpp @@ -46,11 +46,11 @@ const std::vector libretranslate::get_languages() auto json_lang_code = json_language.find("code"); if (json_lang_code != json_language.end()) - language.code = json_lang_code.value(); + language.code = *json_lang_code; auto json_lang_name = json_language.find("name"); if (json_lang_name != json_language.end()) - language.name = json_lang_name.value(); + language.name = *json_lang_name; if (!language.code.empty() && !language.name.empty()) languages.push_back(std::move(language)); @@ -89,7 +89,7 @@ const std::string libretranslate::translate(const std::string &text, const std:: if (response.is_object()) { auto tr_text = response.find("translatedText"); if (tr_text != response.end()) - return tr_text.value(); + return *tr_text; } } } diff --git a/src/webhook_push.cpp b/src/webhook_push.cpp index 8c0fb8c..17822e5 100644 --- a/src/webhook_push.cpp +++ b/src/webhook_push.cpp @@ -77,7 +77,8 @@ void bot::webhook_push::push_request(dpp::snowflake webhook_id, const std::strin { std::promise _p; std::future _f = _p.get_future(); - bot->post_rest(API_PATH "/webhooks", std::to_string(webhook_id), dpp::utility::url_encode(webhook_token), dpp::m_post, json, [bot, &_p](dpp::json &json, const dpp::http_request_completion_t &event) { + bot->post_rest(API_PATH "/webhooks", std::to_string(webhook_id), dpp::utility::url_encode(webhook_token), dpp::m_post, json, [&bot, &_p](dpp::json &json, const dpp::http_request_completion_t &event) { + std::cout << event.body << std::endl; if (event.status != 204) std::cerr << "[Warning] Webhook push returned unexpected code " << event.status << std::endl; _p.set_value(event);