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:35:20 +05:00
parent a6c535e784
commit 3f97369f03
12 changed files with 145 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -79,4 +79,4 @@ target_link_libraries(tests gtest
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED True)
set(CMAKE_CXX_FLAGS "-march=native -O2 -pipe")
#set(CMAKE_CXX_FLAGS "-O0 -pipe")
#set(CMAKE_CXX_FLAGS "-O0 -pipe")

2
include/includes.h
View File

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

2
libs/api/Author.hpp
View File

@ -51,7 +51,7 @@ public:
return data["d"]["author"]["avatar"];
}
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

8
libs/api/Bot.hpp
View File

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

2
libs/api/Channel.hpp
View File

@ -11,7 +11,7 @@ private:
public:
Channel(const json& data = "") : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {}
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

10
libs/api/Message.hpp
View File

@ -11,19 +11,19 @@ private:
public:
Message(const json& data) : data(data), web(WebSocket::getInstance()), req(NetworkManager::getInstance()) {};
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 = "") {
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 {
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) {
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

2
libs/api/User.hpp
View File

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

95
libs/gateway/Websocket.hpp
View File

@ -10,87 +10,12 @@ using namespace std::chrono;
using namespace std::chrono_literals;
class WebSocket {
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;
int intents;
std::string token;
ix::WebSocket webSocket;
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(const WebSocket&) = delete;
WebSocket(const std::string& token, const int& intents, bool& isBot) {
@ -124,20 +49,18 @@ private:
ix::initNetSystem();
webSocket.setUrl("wss://gateway.discord.gg/?v=10&encoding=json");
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 {
if (msg->type == ix::WebSocketMessageType::Message) {
res = json::parse(msg->str);
//#ifdef DEBUG
Logs::create(INFO, WEBSOCKET, res["op"].dump() + " " + res["t"].dump());
//#endif
Log::create(INFO, WEBSOCKET, res["op"].dump() + " " + res["t"].dump());
switch (res["op"].get<int>()) {
case 10:
heartbeat_interval = res["d"]["heartbeat_interval"].get<int>();
!connected ? connected = true, webSocket.send(id.dump()) : 0;
std::thread([this, &heartbeat_interval, &connected]() {
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));
webSocket.send(payload.dump());
}
@ -169,7 +92,7 @@ public:
}
*/
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);
return instance;
}
@ -183,13 +106,13 @@ public:
int getIntents() const {
return WebSocket::intents;
}
void on(const int event, std::function<void(const json&&)> handler) {
eventHandlers[events[event].second] = [handler](const json& message) {
void on(const string& event, std::function<void(const json&)> handler) {
eventHandlers[event] = [handler](const json& message) {
handler(message.get<json>());
};
}
void once(const int event, std::function<void(const json&&)> handler) {
eventHandlers[events[event].second] = [event, handler, isCalled = false](const json& message) mutable {
void once(const string& event, std::function<void(const json&)> handler) {
eventHandlers[event] = [event, handler, isCalled = false](const json& message) mutable {
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(const NetworkManager&) = delete;
NetworkManager() : web(WebSocket::getInstance()) {
Logs::create(INFO, NETWORK, "Network init");
Log::create(INFO, NETWORK, "Network init");
curl_global_init(CURL_GLOBAL_DEFAULT);
curl = curl_easy_init();
if (!curl) {
Logs::create(ERROR, NETWORK, "Failed to initialize CURL");
Log::create(ERROR, NETWORK, "Failed to initialize CURL");
abort();
}
}
@ -32,25 +32,25 @@ private:
}
public:
static NetworkManager& getInstance() {
Logs::create(WARNING, NETWORK, "Instance event");
Log::create(WARNING, NETWORK, "Instance event");
static NetworkManager instance;
return instance;
}
std::string request(const std::string& method, const std::string& path, const std::string& data = "") {
std::string response;
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_POSTFIELDS, data.c_str());
curl_slist* headers = curl_slist_append(headers, "Accept: 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, "User-Agent: DiscordBot");
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2_0);
res = curl_easy_perform(curl);
if (res != 0) Logs::create(ERROR, NETWORK, "curl_easy_perform() failed: " + std::string(curl_easy_strerror(res)));
curl_easy_setopt(curl, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_3ONLY);
if ((res = curl_easy_perform(curl)) != 0) Log::create(ERROR, NETWORK, "curl_easy_perform() failed: " + std::string(curl_easy_strerror(res)));
curl_slist_free_all(headers);
}
return response;

179
libs/utils/enums.hpp
View File

@ -1,79 +1,107 @@
#ifndef UTILS_EVENTS_HPP_
#define UTILS_EVENTS_HPP_
enum GatewayEvents {
APPLICATION_COMMAND_PERMISSIONS_UPDATE,
AUTO_MODERATION_ACTION_EXECUTION,
AUTO_MODERATION_RULE_CREATE,
AUTO_MODERATION_RULE_DELETE,
AUTO_MODERATION_RULE_UPDATE,
CHANNEL_CREATE,
CHANNEL_DELETE,
CHANNEL_PINS_UPDATE,
CHANNEL_UPDATE,
ENTITLEMENT_CREATE,
ENTITLEMENT_DELETE,
ENTITLEMENT_UPDATE,
GUILD_AUDIT_LOG_ENTRY_CREATE,
GUILD_BAN_ADD,
GUILD_BAN_REMOVE,
GUILD_CREATE,
GUILD_DELETE,
GUILD_EMOJIS_UPDATE,
GUILD_INTEGRATIONS_UPDATE,
GUILD_MEMBER_ADD,
GUILD_MEMBER_REMOVE,
GUILD_MEMBERS_CHUNK,
GUILD_MEMBER_UPDATE,
GUILD_ROLE_CREATE,
GUILD_ROLE_DELETE,
GUILD_ROLE_UPDATE,
GUILD_SCHEDULED_EVENT_CREATE,
GUILD_SCHEDULED_EVENT_DELETE,
GUILD_SCHEDULED_EVENT_UPDATE,
GUILD_SCHEDULED_EVENT_USER_REMOVE,
GUILD_SOUNDBOARD_SOUND_CREATE,
GUILD_SOUNDBOARD_SOUND_DELETE,
GUILD_SOUNDBOARD_SOUNDS_UPDATE,
GUILD_SOUNDBOARD_SOUND_UPDATE,
SOUNDBOARD_SOUNDS,
GUILD_STICKERS_UPDATE,
GUILD_UPDATE,
INTEGRATION_CREATE,
INTEGRATION_DELETE,
INTEGRATION_UPDATE,
INVITE_CREATE,
INVITE_DELETE,
MESSAGE_CREATE,
MESSAGE_DELETE,
MESSAGE_DELETE_BULK,
MESSAGE_POLL_VOTE_ADD,
MESSAGE_POLL_VOTE_REMOVE,
MESSAGE_REACTION_ADD,
MESSAGE_REACTION_REMOVE,
MESSAGE_REACTION_REMOVE_ALL,
MESSAGE_REACTION_REMOVE_EMOJI,
MESSAGE_UPDATE,
PRESENCE_UPDATE,
READY,
RESUMED,
STAGE_INSTANCE_CREATE,
STAGE_INSTANCE_DELETE,
STAGE_INSTANCE_UPDATE,
SUBSCRIPTION_CREATE,
SUBSCRIPTION_DELETE,
SUBSCRIPTION_UPDATE,
THREAD_CREATE,
THREAD_DELETE,
THREAD_LIST_SYNC,
THREAD_MEMBERS_UPDATE,
THREAD_MEMBER_UPDATE,
THREAD_UPDATE,
TYPING_START,
USER_UPDATE,
VOICE_CHANNEL_EFFECT_SEND,
VOICE_SERVER_UPDATE,
VOICE_STATE_UPDATE,
WEBHOOKS_UPDATE
struct GatewayEvents {
static constexpr const char* APPLICATION_COMMAND_PERMISSIONS_UPDATE = "APPLICATION_COMMAND_PERMISSIONS_UPDATE";
static constexpr const char* AUTO_MODERATION_ACTION_EXECUTION = "AUTO_MODERATION_ACTION_EXECUTION";
static constexpr const char* AUTO_MODERATION_RULE_CREATE = "AUTO_MODERATION_RULE_CREATE";
static constexpr const char* AUTO_MODERATION_RULE_DELETE = "AUTO_MODERATION_RULE_DELETE";
static constexpr const char* AUTO_MODERATION_RULE_UPDATE = "AUTO_MODERATION_RULE_UPDATE";
static constexpr const char* CHANNEL_CREATE = "CHANNEL_CREATE";
static constexpr const char* CHANNEL_DELETE = "CHANNEL_DELETE";
static constexpr const char* CHANNEL_PINS_UPDATE = "CHANNEL_PINS_UPDATE";
static constexpr const char* CHANNEL_UPDATE = "CHANNEL_UPDATE";
static constexpr const char* ENTITLEMENT_CREATE = "ENTITLEMENT_CREATE";
static constexpr const char* ENTITLEMENT_DELETE = "ENTITLEMENT_DELETE";
static constexpr const char* ENTITLEMENT_UPDATE = "ENTITLEMENT_UPDATE";
static constexpr const char* GUILD_AUDIT_LOG_ENTRY_CREATE = "GUILD_AUDIT_LOG_ENTRY_CREATE";
static constexpr const char* GUILD_BAN_ADD = "GUILD_BAN_ADD";
static constexpr const char* GUILD_BAN_REMOVE = "GUILD_BAN_REMOVE";
static constexpr const char* GUILD_CREATE = "GUILD_CREATE";
static constexpr const char* GUILD_DELETE = "GUILD_DELETE";
static constexpr const char* GUILD_EMOJIS_UPDATE = "GUILD_EMOJIS_UPDATE";
static constexpr const char* GUILD_INTEGRATIONS_UPDATE = "GUILD_INTEGRATIONS_UPDATE";
static constexpr const char* GUILD_MEMBER_ADD = "GUILD_MEMBER_ADD";
static constexpr const char* GUILD_MEMBER_REMOVE = "GUILD_MEMBER_REMOVE";
static constexpr const char* GUILD_MEMBERS_CHUNK = "GUILD_MEMBERS_CHUNK";
static constexpr const char* GUILD_MEMBER_UPDATE = "GUILD_MEMBER_UPDATE";
static constexpr const char* GUILD_ROLE_CREATE = "GUILD_ROLE_CREATE";
static constexpr const char* GUILD_ROLE_DELETE = "GUILD_ROLE_DELETE";
static constexpr const char* GUILD_ROLE_UPDATE = "GUILD_ROLE_UPDATE";
static constexpr const char* GUILD_SCHEDULED_EVENT_CREATE = "GUILD_SCHEDULED_EVENT_CREATE";
static constexpr const char* GUILD_SCHEDULED_EVENT_DELETE = "GUILD_SCHEDULED_EVENT_DELETE";
static constexpr const char* GUILD_SCHEDULED_EVENT_UPDATE = "GUILD_SCHEDULED_EVENT_UPDATE";
static constexpr const char* GUILD_SCHEDULED_EVENT_USER_REMOVE = "GUILD_SCHEDULED_EVENT_USER_REMOVE";
static constexpr const char* GUILD_SOUNDBOARD_SOUND_CREATE = "GUILD_SOUNDBOARD_SOUND_CREATE";
static constexpr const char* GUILD_SOUNDBOARD_SOUND_DELETE = "GUILD_SOUNDBOARD_SOUND_DELETE";
static constexpr const char* GUILD_SOUNDBOARD_SOUNDS_UPDATE = "GUILD_SOUNDBOARD_SOUNDS_UPDATE";
static constexpr const char* GUILD_SOUNDBOARD_SOUND_UPDATE = "GUILD_SOUNDBOARD_SOUND_UPDATE";
static constexpr const char* SOUNDBOARD_SOUNDS = "SOUNDBOARD_SOUNDS";
static constexpr const char* GUILD_STICKERS_UPDATE = "GUILD_STICKERS_UPDATE";
static constexpr const char* GUILD_UPDATE = "GUILD_UPDATE";
static constexpr const char* INTEGRATION_CREATE = "INTEGRATION_CREATE";
static constexpr const char* INTEGRATION_DELETE = "INTEGRATION_DELETE";
static constexpr const char* INTEGRATION_UPDATE = "INTEGRATION_UPDATE";
static constexpr const char* INVITE_CREATE = "INVITE_CREATE";
static constexpr const char* INVITE_DELETE = "INVITE_DELETE";
static constexpr const char* MESSAGE_CREATE = "MESSAGE_CREATE";
static constexpr const char* MESSAGE_DELETE = "MESSAGE_DELETE";
static constexpr const char* MESSAGE_DELETE_BULK = "MESSAGE_DELETE_BULK";
static constexpr const char* MESSAGE_POLL_VOTE_ADD = "MESSAGE_POLL_VOTE_ADD";
static constexpr const char* MESSAGE_POLL_VOTE_REMOVE = "MESSAGE_POLL_VOTE_REMOVE";
static constexpr const char* MESSAGE_REACTION_ADD = "MESSAGE_REACTION_ADD";
static constexpr const char* MESSAGE_REACTION_REMOVE = "MESSAGE_REACTION_REMOVE";
static constexpr const char* MESSAGE_REACTION_REMOVE_ALL = "MESSAGE_REACTION_REMOVE_ALL";
static constexpr const char* MESSAGE_REACTION_REMOVE_EMOJI = "MESSAGE_REACTION_REMOVE_EMOJI";
static constexpr const char* MESSAGE_UPDATE = "MESSAGE_UPDATE";
static constexpr const char* PRESENCE_UPDATE = "PRESENCE_UPDATE";
static constexpr const char* READY = "READY";
static constexpr const char* RESUMED = "RESUMED";
static constexpr const char* STAGE_INSTANCE_CREATE = "STAGE_INSTANCE_CREATE";
static constexpr const char* STAGE_INSTANCE_DELETE = "STAGE_INSTANCE_DELETE";
static constexpr const char* STAGE_INSTANCE_UPDATE = "STAGE_INSTANCE_UPDATE";
static constexpr const char* SUBSCRIPTION_CREATE = "SUBSCRIPTION_CREATE";
static constexpr const char* SUBSCRIPTION_DELETE = "SUBSCRIPTION_DELETE";
static constexpr const char* SUBSCRIPTION_UPDATE = "SUBSCRIPTION_UPDATE";
static constexpr const char* THREAD_CREATE = "THREAD_CREATE";
static constexpr const char* THREAD_DELETE = "THREAD_DELETE";
static constexpr const char* THREAD_LIST_SYNC = "THREAD_LIST_SYNC";
static constexpr const char* THREAD_MEMBERS_UPDATE = "THREAD_MEMBERS_UPDATE";
static constexpr const char* THREAD_MEMBER_UPDATE = "THREAD_MEMBER_UPDATE";
static constexpr const char* THREAD_UPDATE = "THREAD_UPDATE";
static constexpr const char* TYPING_START = "TYPING_START";
static constexpr const char* USER_UPDATE = "USER_UPDATE";
static constexpr const char* VOICE_CHANNEL_EFFECT_SEND = "VOICE_CHANNEL_EFFECT_SEND";
static constexpr const char* VOICE_SERVER_UPDATE = "VOICE_SERVER_UPDATE";
static constexpr const char* VOICE_STATE_UPDATE = "VOICE_STATE_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 {
AutoModerationConfiguration = 1048576,
@ -109,4 +137,7 @@ enum UserStatus {
DoNotDisturb,
Invisible
};
enum DiscordTime {
Epoch = 1420070400000,
};
#endif

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

@ -1,5 +1,5 @@
#ifndef UTILS_LOGS_HPP
#define UTILS_LOGS_HPP
#ifndef UTILS_LOG_HPP
#define UTILS_LOG_HPP
#include <string>
#include <chrono>
#include <iostream>
@ -8,30 +8,30 @@
using std::setfill, std::setw;
enum level { INFO, WARNING, ERROR, CRITICAL };
enum type { WEBSOCKET, NETWORK, API };
class Logs {
class Log {
public:
static void create(level lvl, type t, const std::string& message) {
#ifdef DEBUG
#ifdef DEBUG
std::string color;
switch (lvl) {
case INFO:
color = "\033[34;1m";
color = "\033[34;1m";
break;
case WARNING:
color = "\033[33;1m";
color = "\033[33;1m";
break;
case ERROR:
color = "\033[31;1m";
break;
break;
case CRITICAL:
color = "\033[31;1;2m";
break;
default:
color = "\033[0m";
color = "\033[0m";
break;
}
std::cout << color << "[" << getCurrentTime() << "][" << str(t) << "][" << str(lvl) << "] \033[0m" << message << "\033[0m" << std::endl;
#endif
#endif
}
private:
static std::string getCurrentTime() {

3
libs/utils/types.hpp
View File

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