rcxpony/sparkle
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Activity

code cleanup

Browse Source
This commit is contained in:
fluttershy 2025-01-19 04:40:15 +05:00
commit cb7adad834
12 changed files with 156 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
CMakeLists.txt
View File

@ -7,16 +7,12 @@ include(GoogleTest)
set(SOURCE sources/main.cpp) set(SOURCE sources/main.cpp)
set(LIBS ${CMAKE_SOURCE_DIR}/libs/) set(LIBS ${CMAKE_SOURCE_DIR}/libs/)
set(INCLUDE ${CMAKE_SOURCE_DIR}/include/) set(INCLUDE ${CMAKE_SOURCE_DIR}/include/)
set(TESTS ${CMAKE_SOURCE_DIR}/tests) #set(TESTS ${CMAKE_SOURCE_DIR}/tests)
find_package(CURL REQUIRED) find_package(CURL REQUIRED)
find_path(IXWEBSOCKET_INCLUDE_DIR ixwebsocket) find_path(IXWEBSOCKET_INCLUDE_DIR ixwebsocket)
find_library(IXWEBSOCKET_LIBRARIES ixwebsocket) find_library(IXWEBSOCKET_LIBRARIES ixwebsocket)
message(STATUS "IXWEBSOCKET_LIBRARIES: ${IXWEBSOCKET_LIBRARIES}")
message(STATUS "CURL_LIBRARIES: ${CURL_LIBRARIES}")
if(NOT IXWEBSOCKET_INCLUDE_DIR OR NOT IXWEBSOCKET_LIBRARIES) if(NOT IXWEBSOCKET_INCLUDE_DIR OR NOT IXWEBSOCKET_LIBRARIES)
message(FATAL_ERROR "ixwebsocket not found") message(FATAL_ERROR "ixwebsocket not found")
endif() endif()

2
include/includes.h
View File

@ -2,7 +2,7 @@
#define INCLUDE_INCLUDES_H_ #define INCLUDE_INCLUDES_H_
#include <utils/types.hpp> #include <utils/types.hpp>
#include <utils/json.hpp> #include <utils/json.hpp>
#include <utils/logs.hpp> #include <utils/log.hpp>
#include <utils/enums.hpp> #include <utils/enums.hpp>
#include <iostream> #include <iostream>
#include <string> #include <string>

2
libs/api/Author.hpp
View File

@ -51,7 +51,7 @@ public:
return data["d"]["author"]["avatar"]; return data["d"]["author"]["avatar"];
} }
string send(const json& msg) { string send(const json& msg) {
return req.request("POST", dapi + "/channels/" + data["d"]["channel_id"].get<string>() + "/messages", msg.dump()); return req.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/" + data["d"]["channel_id"].get<string>() + "/messages", msg.dump());
} }
}; };
#endif #endif

8
libs/api/Bot.hpp
View File

@ -3,7 +3,7 @@
#include <includes.h> #include <includes.h>
using std::string, std::cout, std::endl, nlohmann::json; using std::string, std::cout, std::endl, nlohmann::json;
template<typename...Args> template<typename...Args>
class Bot { class Discord {
private: private:
void initializeNets(const json& data) { void initializeNets(const json& data) {
initializeNetsImpl(data, std::index_sequence_for<Args...>{}); initializeNetsImpl(data, std::index_sequence_for<Args...>{});
@ -15,15 +15,15 @@ private:
json data; json data;
public: public:
std::tuple<std::unique_ptr<Args>...> net; std::tuple<std::unique_ptr<Args>...> net;
Bot(const json& data) : data(data) { Discord(const json& data) : data(data) {
initializeNets(data); initializeNets(data);
} }
}; };
class BotHandler : Bot<> { class Bot {
private: private:
json data; json data;
public: public:
BotHandler(const json& data) : data(data), Bot(data) {}; Bot(const json& data) : data(data) {};
string id() { string id() {
return data["d"]["id"]; return data["d"]["id"];
} }

2
libs/api/Channel.hpp
View File

@ -11,7 +11,7 @@ private:
public: public:
Channel(const json& data = "") : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {} Channel(const json& data = "") : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {}
string send(const json& msg) { string send(const json& msg) {
return req.request("POST", dapi + "/channels/" + data["d"]["channel_id"].get<string>() + "/messages", msg.dump()); return req.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/" + data["d"]["channel_id"].get<string>() + "/messages", msg.dump());
} }
}; };
#endif #endif

10
libs/api/Message.hpp
View File

@ -11,19 +11,19 @@ private:
public: public:
Message(const json& data) : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {}; Message(const json& data) : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {};
string send(const string& id, const json& msg) { string send(const string& id, const json& msg) {
return req.request("POST", dapi + "/channels/" + id + "/messages", msg.dump()); return req.request(HttpMethods::POST, DiscordEndpoints::details::latest + "/channels/" + id + "/messages", msg.dump());
} }
string getMessages(const string& id, const string& count, const string& before = "") { string getMessages(const string& id, const string& count, const string& before = "") {
if (before.empty()) { if (before.empty()) {
return req.request("GET", dapi + "/channels/" + id + "/messages?limit=" + count); return req.request(HttpMethods::GET, DiscordEndpoints::details::latest + "/channels/" + id + "/messages?limit=" + count);
} }
else { else {
return req.request("GET", dapi + "/channels/" + id + "/messages?before=" + before + "&limit=" + count); return req.request(HttpMethods::GET, DiscordEndpoints::details::latest + "/channels/" + id + "/messages?before=" + before + "&limit=" + count);
} }
return "pizda"; return "";
} }
string deleteMessage(const string& channel_id, const string& message_id) { string deleteMessage(const string& channel_id, const string& message_id) {
return req.request("DELETE", dapi + "/channels/" + channel_id + "/messages/" + message_id); return req.request(HttpMethods::DELETE, DiscordEndpoints::details::latest + "/channels/" + channel_id + "/messages/" + message_id);
} }
}; };
#endif #endif

2
libs/api/User.hpp
View File

@ -26,7 +26,7 @@ public:
return current; return current;
} }
virtual string me() { virtual string me() {
return req.request("GET", dapi + "/users/@me"); return req.request(HttpMethods::GET, DiscordEndpoints::details::latest + "/users/@me");
} }
bool isBot() { bool isBot() {
try { try {

95
libs/gateway/Websocket.hpp
View File

@ -10,87 +10,12 @@ using namespace std::chrono;
using namespace std::chrono_literals; using namespace std::chrono_literals;
class WebSocket { class WebSocket {
private: private:
const std::array<std::pair<const int, std::string_view>, 73> events = { {
{APPLICATION_COMMAND_PERMISSIONS_UPDATE, "APPLICATION_COMMAND_PERMISSIONS_UPDATE"},
{AUTO_MODERATION_ACTION_EXECUTION, "AUTO_MODERATION_ACTION_EXECUTION"},
{AUTO_MODERATION_RULE_CREATE, "AUTO_MODERATION_RULE_CREATE"},
{AUTO_MODERATION_RULE_DELETE, "AUTO_MODERATION_RULE_DELETE"},
{AUTO_MODERATION_RULE_UPDATE, "AUTO_MODERATION_RULE_UPDATE"},
{CHANNEL_CREATE, "CHANNEL_CREATE"},
{CHANNEL_DELETE, "CHANNEL_DELETE"},
{CHANNEL_PINS_UPDATE, "CHANNEL_PINS_UPDATE"},
{CHANNEL_UPDATE, "CHANNEL_UPDATE"},
{ENTITLEMENT_CREATE, "ENTITLEMENT_CREATE"},
{ENTITLEMENT_DELETE, "ENTITLEMENT_DELETE"},
{ENTITLEMENT_UPDATE, "ENTITLEMENT_UPDATE"},
{GUILD_AUDIT_LOG_ENTRY_CREATE, "GUILD_AUDIT_LOG_ENTRY_CREATE"},
{GUILD_BAN_ADD, "GUILD_BAN_ADD"},
{GUILD_BAN_REMOVE, "GUILD_BAN_REMOVE"},
{GUILD_CREATE, "GUILD_CREATE"},
{GUILD_DELETE, "GUILD_DELETE"},
{GUILD_EMOJIS_UPDATE, "GUILD_EMOJIS_UPDATE"},
{GUILD_INTEGRATIONS_UPDATE, "GUILD_INTEGRATIONS_UPDATE"},
{GUILD_MEMBER_ADD, "GUILD_MEMBER_ADD"},
{GUILD_MEMBER_REMOVE, "GUILD_MEMBER_REMOVE"},
{GUILD_MEMBERS_CHUNK, "GUILD_MEMBERS_CHUNK"},
{GUILD_MEMBER_UPDATE, "GUILD_MEMBER_UPDATE"},
{GUILD_ROLE_CREATE, "GUILD_ROLE_CREATE"},
{GUILD_ROLE_DELETE, "GUILD_ROLE_DELETE"},
{GUILD_ROLE_UPDATE, "GUILD_ROLE_UPDATE"},
{GUILD_SCHEDULED_EVENT_CREATE, "GUILD_SCHEDULED_EVENT_CREATE"},
{GUILD_SCHEDULED_EVENT_DELETE, "GUILD_SCHEDULED_EVENT_DELETE"},
{GUILD_SCHEDULED_EVENT_UPDATE, "GUILD_SCHEDULED_EVENT_UPDATE"},
{GUILD_SCHEDULED_EVENT_USER_REMOVE, "GUILD_SCHEDULED_EVENT_USER_REMOVE"},
{GUILD_SOUNDBOARD_SOUND_CREATE, "GUILD_SOUNDBOARD_SOUND_CREATE"},
{GUILD_SOUNDBOARD_SOUND_DELETE, "GUILD_SOUNDBOARD_SOUND_DELETE"},
{GUILD_SOUNDBOARD_SOUNDS_UPDATE, "GUILD_SOUNDBOARD_SOUNDS_UPDATE"},
{GUILD_SOUNDBOARD_SOUND_UPDATE, "GUILD_SOUNDBOARD_SOUND_UPDATE"},
{SOUNDBOARD_SOUNDS, "SOUNDBOARD_SOUNDS"},
{GUILD_STICKERS_UPDATE, "GUILD_STICKERS_UPDATE"},
{GUILD_UPDATE, "GUILD_UPDATE"},
{INTEGRATION_CREATE, "INTEGRATION_CREATE"},
{INTEGRATION_DELETE, "INTEGRATION_DELETE"},
{INTEGRATION_UPDATE, "INTEGRATION_UPDATE"},
{INVITE_CREATE, "INVITE_CREATE"},
{INVITE_DELETE, "INVITE_DELETE"},
{MESSAGE_CREATE, "MESSAGE_CREATE"},
{MESSAGE_DELETE, "MESSAGE_DELETE"},
{MESSAGE_DELETE_BULK, "MESSAGE_DELETE_BULK"},
{MESSAGE_POLL_VOTE_ADD, "MESSAGE_POLL_VOTE_ADD"},
{MESSAGE_POLL_VOTE_REMOVE, "MESSAGE_POLL_VOTE_REMOVE"},
{MESSAGE_REACTION_ADD, "MESSAGE_REACTION_ADD"},
{MESSAGE_REACTION_REMOVE, "MESSAGE_REACTION_REMOVE"},
{MESSAGE_REACTION_REMOVE_ALL, "MESSAGE_REACTION_REMOVE_ALL"},
{MESSAGE_REACTION_REMOVE_EMOJI, "MESSAGE_REACTION_REMOVE_EMOJI"},
{MESSAGE_UPDATE, "MESSAGE_UPDATE"},
{PRESENCE_UPDATE, "PRESENCE_UPDATE"},
{READY, "READY"},
{RESUMED, "RESUMED"},
{STAGE_INSTANCE_CREATE, "STAGE_INSTANCE_CREATE"},
{STAGE_INSTANCE_DELETE, "STAGE_INSTANCE_DELETE"},
{SUBSCRIPTION_CREATE, "SUBSCRIPTION_CREATE"},
{STAGE_INSTANCE_UPDATE, "STAGE_INSTANCE_UPDATE"},
{SUBSCRIPTION_DELETE, "SUBSCRIPTION_DELETE"},
{SUBSCRIPTION_UPDATE, "SUBSCRIPTION_UPDATE"},
{THREAD_CREATE, "THREAD_CREATE"},
{THREAD_DELETE, "THREAD_DELETE"},
{THREAD_LIST_SYNC, "THREAD_LIST_SYNC"},
{THREAD_MEMBERS_UPDATE, "THREAD_MEMBERS_UPDATE"},
{THREAD_MEMBER_UPDATE, "THREAD_MEMBER_UPDATE"},
{THREAD_UPDATE, "THREAD_UPDATE"},
{TYPING_START, "TYPING_START"},
{USER_UPDATE, "USER_UPDATE"},
{VOICE_CHANNEL_EFFECT_SEND, "VOICE_CHANNEL_EFFECT_SEND"},
{VOICE_SERVER_UPDATE, "VOICE_SERVER_UPDATE"},
{VOICE_STATE_UPDATE, "VOICE_STATE_UPDATE"},
{WEBHOOKS_UPDATE, "WEBHOOKS_UPDATE"}
}};
bool isBot; bool isBot;
int intents; int intents;
std::string token; std::string token;
ix::WebSocket webSocket; ix::WebSocket webSocket;
json payload = { {"op", 1},{"d", nullptr} }, id; json payload = { {"op", 1},{"d", nullptr} }, id;
std::unordered_map<std::string_view, std::function<void(const json&)>> eventHandlers; std::unordered_map<std::string, std::function<void(const json&)>> eventHandlers;
WebSocket& operator=(const WebSocket&) = delete; WebSocket& operator=(const WebSocket&) = delete;
WebSocket(const WebSocket&) = delete; WebSocket(const WebSocket&) = delete;
WebSocket(const std::string& token, const int& intents, bool& isBot) { WebSocket(const std::string& token, const int& intents, bool& isBot) {
@ -124,20 +49,18 @@ private:
ix::initNetSystem(); ix::initNetSystem();
webSocket.setUrl("wss://gateway.discord.gg/?v=10&encoding=json"); webSocket.setUrl("wss://gateway.discord.gg/?v=10&encoding=json");
webSocket.setHandshakeTimeout(5); webSocket.setHandshakeTimeout(5);
Logs::create(INFO, WEBSOCKET, "ixwebsocket init"); Log::create(INFO, WEBSOCKET, "ixwebsocket init");
webSocket.setOnMessageCallback([this, res = json(), heartbeat_interval = 0, connected = false](const ix::WebSocketMessagePtr& msg) mutable { webSocket.setOnMessageCallback([this, res = json(), heartbeat_interval = 0, connected = false](const ix::WebSocketMessagePtr& msg) mutable {
if (msg->type == ix::WebSocketMessageType::Message) { if (msg->type == ix::WebSocketMessageType::Message) {
res = json::parse(msg->str); res = json::parse(msg->str);
//#ifdef DEBUG Log::create(INFO, WEBSOCKET, res["op"].dump() + " " + res["t"].dump());
Logs::create(INFO, WEBSOCKET, res["op"].dump() + " " + res["t"].dump());
//#endif
switch (res["op"].get<int>()) { switch (res["op"].get<int>()) {
case 10: case 10:
heartbeat_interval = res["d"]["heartbeat_interval"].get<int>(); heartbeat_interval = res["d"]["heartbeat_interval"].get<int>();
!connected ? connected = true, webSocket.send(id.dump()) : 0; !connected ? connected = true, webSocket.send(id.dump()) : 0;
std::thread([this, &heartbeat_interval, &connected]() { std::thread([this, &heartbeat_interval, &connected]() {
while (connected && heartbeat_interval != -1) { while (connected && heartbeat_interval != -1) {
Logs::create(INFO, WEBSOCKET, "Heartbeat " + std::to_string(heartbeat_interval)); Log::create(INFO, WEBSOCKET, "Heartbeat " + std::to_string(heartbeat_interval));
std::this_thread::sleep_for(milliseconds(heartbeat_interval)); std::this_thread::sleep_for(milliseconds(heartbeat_interval));
webSocket.send(payload.dump()); webSocket.send(payload.dump());
} }
@ -169,7 +92,7 @@ public:
} }
*/ */
static WebSocket& getInstance(const std::string& token = "", const int intents = 0, bool bot = true) { static WebSocket& getInstance(const std::string& token = "", const int intents = 0, bool bot = true) {
Logs::create(WARNING, WEBSOCKET, "Instance event"); Log::create(WARNING, WEBSOCKET, "Instance event");
static WebSocket instance(token, intents, bot); static WebSocket instance(token, intents, bot);
return instance; return instance;
} }
@ -183,13 +106,13 @@ public:
int getIntents() const { int getIntents() const {
return WebSocket::intents; return WebSocket::intents;
} }
void on(const int event, std::function<void(const json&&)> handler) { void on(const string& event, std::function<void(const json&)> handler) {
eventHandlers[events[event].second] = [handler](const json& message) { eventHandlers[event] = [handler](const json& message) {
handler(message.get<json>()); handler(message.get<json>());
}; };
} }
void once(const int event, std::function<void(const json&&)> handler) { void once(const string& event, std::function<void(const json&)> handler) {
eventHandlers[events[event].second] = [event, handler, isCalled = false](const json& message) mutable { eventHandlers[event] = [event, handler, isCalled = false](const json& message) mutable {
isCalled == false ? isCalled = true : 0, handler(message.get<json>()); isCalled == false ? isCalled = true : 0, handler(message.get<json>());
}; };
} }

14
libs/tls/Network.hpp
View File

@ -12,11 +12,11 @@ private:
NetworkManager& operator=(const NetworkManager&) = delete; NetworkManager& operator=(const NetworkManager&) = delete;
NetworkManager(const NetworkManager&) = delete; NetworkManager(const NetworkManager&) = delete;
NetworkManager() : web(WebSocket::getInstance()) { NetworkManager() : web(WebSocket::getInstance()) {
Logs::create(INFO, NETWORK, "Network init"); Log::create(INFO, NETWORK, "Network init");
curl_global_init(CURL_GLOBAL_DEFAULT); curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init(); curl = curl_easy_init();
if (!curl) { if (!curl) {
Logs::create(ERROR, NETWORK, "Failed to initialize CURL"); Log::create(ERROR, NETWORK, "Failed to initialize CURL");
abort(); abort();
} }
} }
@ -32,25 +32,25 @@ private:
} }
public: public:
static NetworkManager& getInstance() { static NetworkManager& getInstance() {
Logs::create(WARNING, NETWORK, "Instance event"); Log::create(WARNING, NETWORK, "Instance event");
static NetworkManager instance; static NetworkManager instance;
return instance; return instance;
} }
std::string request(const std::string& method, const std::string& path, const std::string& data = "") { std::string request(const std::string& method, const std::string& path, const std::string& data = "") {
std::string response; std::string response;
if (curl) { if (curl) {
curl_easy_setopt(curl, CURLOPT_URL, string("https://discord.com" + path).c_str()); curl_easy_setopt(curl, CURLOPT_URL, path.c_str());
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, method.c_str()); curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, method.c_str());
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data.c_str()); curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data.c_str());
curl_slist* headers = curl_slist_append(headers, "Accept: application/json"); curl_slist* headers = curl_slist_append(headers, "Accept: application/json");
headers = curl_slist_append(headers, "Content-Type: application/json"); headers = curl_slist_append(headers, "Content-Type: application/json");
headers = curl_slist_append(headers, ("Authorization: " + web.getToken()).c_str()); headers = curl_slist_append(headers, ("Authorization: " + web.getToken()).c_str());
headers = curl_slist_append(headers, "User-Agent: DiscordBot");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers); curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response); curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0); curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_3ONLY);
res = curl_easy_perform(curl); if ((res = curl_easy_perform(curl)) != 0) Log::create(ERROR, NETWORK, "curl_easy_perform() failed: " + std::string(curl_easy_strerror(res)));
if (res != 0) Logs::create(ERROR, NETWORK, "curl_easy_perform() failed: " + std::string(curl_easy_strerror(res)));
curl_slist_free_all(headers); curl_slist_free_all(headers);
} }
return response; return response;

179
libs/utils/enums.hpp
View File

@ -1,79 +1,107 @@
#ifndef UTILS_EVENTS_HPP_ #ifndef UTILS_EVENTS_HPP_
#define UTILS_EVENTS_HPP_ #define UTILS_EVENTS_HPP_
enum GatewayEvents { struct GatewayEvents {
APPLICATION_COMMAND_PERMISSIONS_UPDATE, static constexpr const char* APPLICATION_COMMAND_PERMISSIONS_UPDATE = "APPLICATION_COMMAND_PERMISSIONS_UPDATE";
AUTO_MODERATION_ACTION_EXECUTION, static constexpr const char* AUTO_MODERATION_ACTION_EXECUTION = "AUTO_MODERATION_ACTION_EXECUTION";
AUTO_MODERATION_RULE_CREATE, static constexpr const char* AUTO_MODERATION_RULE_CREATE = "AUTO_MODERATION_RULE_CREATE";
AUTO_MODERATION_RULE_DELETE, static constexpr const char* AUTO_MODERATION_RULE_DELETE = "AUTO_MODERATION_RULE_DELETE";
AUTO_MODERATION_RULE_UPDATE, static constexpr const char* AUTO_MODERATION_RULE_UPDATE = "AUTO_MODERATION_RULE_UPDATE";
CHANNEL_CREATE, static constexpr const char* CHANNEL_CREATE = "CHANNEL_CREATE";
CHANNEL_DELETE, static constexpr const char* CHANNEL_DELETE = "CHANNEL_DELETE";
CHANNEL_PINS_UPDATE, static constexpr const char* CHANNEL_PINS_UPDATE = "CHANNEL_PINS_UPDATE";
CHANNEL_UPDATE, static constexpr const char* CHANNEL_UPDATE = "CHANNEL_UPDATE";
ENTITLEMENT_CREATE, static constexpr const char* ENTITLEMENT_CREATE = "ENTITLEMENT_CREATE";
ENTITLEMENT_DELETE, static constexpr const char* ENTITLEMENT_DELETE = "ENTITLEMENT_DELETE";
ENTITLEMENT_UPDATE, static constexpr const char* ENTITLEMENT_UPDATE = "ENTITLEMENT_UPDATE";
GUILD_AUDIT_LOG_ENTRY_CREATE, static constexpr const char* GUILD_AUDIT_LOG_ENTRY_CREATE = "GUILD_AUDIT_LOG_ENTRY_CREATE";
GUILD_BAN_ADD, static constexpr const char* GUILD_BAN_ADD = "GUILD_BAN_ADD";
GUILD_BAN_REMOVE, static constexpr const char* GUILD_BAN_REMOVE = "GUILD_BAN_REMOVE";
GUILD_CREATE, static constexpr const char* GUILD_CREATE = "GUILD_CREATE";
GUILD_DELETE, static constexpr const char* GUILD_DELETE = "GUILD_DELETE";
GUILD_EMOJIS_UPDATE, static constexpr const char* GUILD_EMOJIS_UPDATE = "GUILD_EMOJIS_UPDATE";
GUILD_INTEGRATIONS_UPDATE, static constexpr const char* GUILD_INTEGRATIONS_UPDATE = "GUILD_INTEGRATIONS_UPDATE";
GUILD_MEMBER_ADD, static constexpr const char* GUILD_MEMBER_ADD = "GUILD_MEMBER_ADD";
GUILD_MEMBER_REMOVE, static constexpr const char* GUILD_MEMBER_REMOVE = "GUILD_MEMBER_REMOVE";
GUILD_MEMBERS_CHUNK, static constexpr const char* GUILD_MEMBERS_CHUNK = "GUILD_MEMBERS_CHUNK";
GUILD_MEMBER_UPDATE, static constexpr const char* GUILD_MEMBER_UPDATE = "GUILD_MEMBER_UPDATE";
GUILD_ROLE_CREATE, static constexpr const char* GUILD_ROLE_CREATE = "GUILD_ROLE_CREATE";
GUILD_ROLE_DELETE, static constexpr const char* GUILD_ROLE_DELETE = "GUILD_ROLE_DELETE";
GUILD_ROLE_UPDATE, static constexpr const char* GUILD_ROLE_UPDATE = "GUILD_ROLE_UPDATE";
GUILD_SCHEDULED_EVENT_CREATE, static constexpr const char* GUILD_SCHEDULED_EVENT_CREATE = "GUILD_SCHEDULED_EVENT_CREATE";
GUILD_SCHEDULED_EVENT_DELETE, static constexpr const char* GUILD_SCHEDULED_EVENT_DELETE = "GUILD_SCHEDULED_EVENT_DELETE";
GUILD_SCHEDULED_EVENT_UPDATE, static constexpr const char* GUILD_SCHEDULED_EVENT_UPDATE = "GUILD_SCHEDULED_EVENT_UPDATE";
GUILD_SCHEDULED_EVENT_USER_REMOVE, static constexpr const char* GUILD_SCHEDULED_EVENT_USER_REMOVE = "GUILD_SCHEDULED_EVENT_USER_REMOVE";
GUILD_SOUNDBOARD_SOUND_CREATE, static constexpr const char* GUILD_SOUNDBOARD_SOUND_CREATE = "GUILD_SOUNDBOARD_SOUND_CREATE";
GUILD_SOUNDBOARD_SOUND_DELETE, static constexpr const char* GUILD_SOUNDBOARD_SOUND_DELETE = "GUILD_SOUNDBOARD_SOUND_DELETE";
GUILD_SOUNDBOARD_SOUNDS_UPDATE, static constexpr const char* GUILD_SOUNDBOARD_SOUNDS_UPDATE = "GUILD_SOUNDBOARD_SOUNDS_UPDATE";
GUILD_SOUNDBOARD_SOUND_UPDATE, static constexpr const char* GUILD_SOUNDBOARD_SOUND_UPDATE = "GUILD_SOUNDBOARD_SOUND_UPDATE";
SOUNDBOARD_SOUNDS, static constexpr const char* SOUNDBOARD_SOUNDS = "SOUNDBOARD_SOUNDS";
GUILD_STICKERS_UPDATE, static constexpr const char* GUILD_STICKERS_UPDATE = "GUILD_STICKERS_UPDATE";
GUILD_UPDATE, static constexpr const char* GUILD_UPDATE = "GUILD_UPDATE";
INTEGRATION_CREATE, static constexpr const char* INTEGRATION_CREATE = "INTEGRATION_CREATE";
INTEGRATION_DELETE, static constexpr const char* INTEGRATION_DELETE = "INTEGRATION_DELETE";
INTEGRATION_UPDATE, static constexpr const char* INTEGRATION_UPDATE = "INTEGRATION_UPDATE";
INVITE_CREATE, static constexpr const char* INVITE_CREATE = "INVITE_CREATE";
INVITE_DELETE, static constexpr const char* INVITE_DELETE = "INVITE_DELETE";
MESSAGE_CREATE, static constexpr const char* MESSAGE_CREATE = "MESSAGE_CREATE";
MESSAGE_DELETE, static constexpr const char* MESSAGE_DELETE = "MESSAGE_DELETE";
MESSAGE_DELETE_BULK, static constexpr const char* MESSAGE_DELETE_BULK = "MESSAGE_DELETE_BULK";
MESSAGE_POLL_VOTE_ADD, static constexpr const char* MESSAGE_POLL_VOTE_ADD = "MESSAGE_POLL_VOTE_ADD";
MESSAGE_POLL_VOTE_REMOVE, static constexpr const char* MESSAGE_POLL_VOTE_REMOVE = "MESSAGE_POLL_VOTE_REMOVE";
MESSAGE_REACTION_ADD, static constexpr const char* MESSAGE_REACTION_ADD = "MESSAGE_REACTION_ADD";
MESSAGE_REACTION_REMOVE, static constexpr const char* MESSAGE_REACTION_REMOVE = "MESSAGE_REACTION_REMOVE";
MESSAGE_REACTION_REMOVE_ALL, static constexpr const char* MESSAGE_REACTION_REMOVE_ALL = "MESSAGE_REACTION_REMOVE_ALL";
MESSAGE_REACTION_REMOVE_EMOJI, static constexpr const char* MESSAGE_REACTION_REMOVE_EMOJI = "MESSAGE_REACTION_REMOVE_EMOJI";
MESSAGE_UPDATE, static constexpr const char* MESSAGE_UPDATE = "MESSAGE_UPDATE";
PRESENCE_UPDATE, static constexpr const char* PRESENCE_UPDATE = "PRESENCE_UPDATE";
READY, static constexpr const char* READY = "READY";
RESUMED, static constexpr const char* RESUMED = "RESUMED";
STAGE_INSTANCE_CREATE, static constexpr const char* STAGE_INSTANCE_CREATE = "STAGE_INSTANCE_CREATE";
STAGE_INSTANCE_DELETE, static constexpr const char* STAGE_INSTANCE_DELETE = "STAGE_INSTANCE_DELETE";
STAGE_INSTANCE_UPDATE, static constexpr const char* STAGE_INSTANCE_UPDATE = "STAGE_INSTANCE_UPDATE";
SUBSCRIPTION_CREATE, static constexpr const char* SUBSCRIPTION_CREATE = "SUBSCRIPTION_CREATE";
SUBSCRIPTION_DELETE, static constexpr const char* SUBSCRIPTION_DELETE = "SUBSCRIPTION_DELETE";
SUBSCRIPTION_UPDATE, static constexpr const char* SUBSCRIPTION_UPDATE = "SUBSCRIPTION_UPDATE";
THREAD_CREATE, static constexpr const char* THREAD_CREATE = "THREAD_CREATE";
THREAD_DELETE, static constexpr const char* THREAD_DELETE = "THREAD_DELETE";
THREAD_LIST_SYNC, static constexpr const char* THREAD_LIST_SYNC = "THREAD_LIST_SYNC";
THREAD_MEMBERS_UPDATE, static constexpr const char* THREAD_MEMBERS_UPDATE = "THREAD_MEMBERS_UPDATE";
THREAD_MEMBER_UPDATE, static constexpr const char* THREAD_MEMBER_UPDATE = "THREAD_MEMBER_UPDATE";
THREAD_UPDATE, static constexpr const char* THREAD_UPDATE = "THREAD_UPDATE";
TYPING_START, static constexpr const char* TYPING_START = "TYPING_START";
USER_UPDATE, static constexpr const char* USER_UPDATE = "USER_UPDATE";
VOICE_CHANNEL_EFFECT_SEND, static constexpr const char* VOICE_CHANNEL_EFFECT_SEND = "VOICE_CHANNEL_EFFECT_SEND";
VOICE_SERVER_UPDATE, static constexpr const char* VOICE_SERVER_UPDATE = "VOICE_SERVER_UPDATE";
VOICE_STATE_UPDATE, static constexpr const char* VOICE_STATE_UPDATE = "VOICE_STATE_UPDATE";
WEBHOOKS_UPDATE static constexpr const char* WEBHOOKS_UPDATE = "WEBHOOKS_UPDATE";
};
struct HttpMethods {
static constexpr const char* POST = "POST";
static constexpr const char* GET = "GET";
static constexpr const char* PATCH = "PATCH";
static constexpr const char* DELETE = "DELETE";
static constexpr const char* PUT = "PUT";
static constexpr const char* OPTIONS = "OPTIONS";
};
struct ApiVersion {
static inline std::string api = "/api/";
static inline std::string v10 = "v10";
static inline std::string v9 = "v9";
static inline std::string v8 = "v8";
static inline std::string v7 = "v7";
static inline std::string v6 = "v6";
static inline std::string current = api + v6;
static inline std::string latest = api + v10;
};
struct DiscordEndpoints {
static inline std::string main_scheme = "https://";
static inline std::string discord = main_scheme + "discord.com";
static inline std::string images = main_scheme + "cdn.discord.com";
static inline std::string media = main_scheme + "media.discord.com";
struct details {
static inline std::string current = DiscordEndpoints::discord + ApiVersion::current;
static inline std::string latest = DiscordEndpoints::discord + ApiVersion::latest;
};
}; };
enum GatewayIntents { enum GatewayIntents {
AutoModerationConfiguration = 1048576, AutoModerationConfiguration = 1048576,
@ -109,4 +137,7 @@ enum UserStatus {
DoNotDisturb, DoNotDisturb,
Invisible Invisible
}; };
enum DiscordTime {
Epoch = 1420070400000,
};
#endif #endif

27
libs/utils/logs.hpp → libs/utils/log.hpp
View File

@ -1,33 +1,36 @@
#ifndef UTILS_LOGS_HPP #ifndef UTILS_LOG_HPP
#define UTILS_LOGS_HPP #define UTILS_LOG_HPP
#include <string> #include <string>
#include <chrono> #include <chrono>
#include <iostream> #include <iostream>
#include <iomanip> #include <iomanip>
#include <ctime> #include <ctime>
using std::setfill, std::setw; using std::setfill, std::setw;
enum level { INFO, WARNING, ERROR }; enum level { INFO, WARNING, ERROR, CRITICAL };
enum type { WEBSOCKET, NETWORK }; enum type { WEBSOCKET, NETWORK, API };
class Logs { class Log {
public: public:
static void create(level lvl, type t, const std::string& message) { static void create(level lvl, type t, const std::string& message) {
#ifdef DEBUG #ifdef DEBUG
std::string color; std::string color;
switch (lvl) { switch (lvl) {
case INFO: case INFO:
color = "\033[34m"; color = "\033[34;1m";
break; break;
case WARNING: case WARNING:
color = "\033[33m"; color = "\033[33;1m";
break; break;
case ERROR: case ERROR:
color = "\033[31m"; color = "\033[31;1m";
break;
case CRITICAL:
color = "\033[31;1;2m";
break; break;
default: default:
color = "\033[0m"; color = "\033[0m";
break; break;
} }
std::cout << color << "[" << getCurrentTime() << "][" << str(t) << "][" << str(lvl) << "] \033[37m" << message << "\033[0m" << std::endl; std::cout << color << "[" << getCurrentTime() << "][" << str(t) << "][" << str(lvl) << "] \033[0m" << message << "\033[0m" << std::endl;
#endif #endif
} }
private: private:
@ -38,18 +41,20 @@ private:
oss << setfill('0') << setw(2) << timer->tm_hour << ":" << setfill('0') << setw(2) << timer->tm_min << ":" << setfill('0') << setw(2) << timer->tm_sec; oss << setfill('0') << setw(2) << timer->tm_hour << ":" << setfill('0') << setw(2) << timer->tm_min << ":" << setfill('0') << setw(2) << timer->tm_sec;
return oss.str(); return oss.str();
} }
static std::string str(level lvl) { static std::string str(const level& lvl) {
switch (lvl) { switch (lvl) {
case INFO: return "INFO"; case INFO: return "INFO";
case WARNING: return "WARNING"; case WARNING: return "WARNING";
case ERROR: return "ERROR"; case ERROR: return "ERROR";
case CRITICAL: return "CRITICAL";
default: return "UNKNOWN"; default: return "UNKNOWN";
} }
} }
static std::string str(type t) { static std::string str(const type& t) {
switch (t) { switch (t) {
case WEBSOCKET: return "WEBSOCKET"; case WEBSOCKET: return "WEBSOCKET";
case NETWORK: return "NETWORK"; case NETWORK: return "NETWORK";
case API: return "API";
default: return "UNKNOWN"; default: return "UNKNOWN";
} }
} }

3
libs/utils/types.hpp
View File

@ -1,9 +1,8 @@
#ifndef UTILS_TYPES_HPP_ #ifndef UTILS_TYPES_HPP_
#define UTILS_TYPES_HPP_ #define UTILS_TYPES_HPP_
#define dapi string("/api/v10")
#define j(...) {{__VA_ARGS__}} #define j(...) {{__VA_ARGS__}}
#define je(...) {__VA_ARGS__} #define je(...) {__VA_ARGS__}
#define g(x, y) (std::get<x>(y)) #define g(x, y) (std::get<x>(y))
#define ALL_INTENTS 131071 #define ALL_INTENTS 131071
#define RELEASE #define DEBUG
#endif #endif