view user profile (notes+connections+badges)

change some stuff with callbacks

6 files changed, 239 insertions, 36 deletions

diff --git a/discord/discord.cpp b/discord/discord.cpp
index df326d8..29e1101 100644
--- a/discord/discord.cpp
+++ b/discord/discord.cpp
@@ -112,8 +112,6 @@ std::set<Snowflake> DiscordClient::GetMessagesForChannel(Snowflake id) const {
 }
 
 void DiscordClient::FetchInvite(std::string code, sigc::slot<void(std::optional<InviteData>)> callback) {
-    sigc::signal<void, std::optional<InviteData>> signal;
-    signal.connect(callback);
     m_http.MakeGET("/invites/" + code + "?with_counts=true", [this, callback](http::response_type r) {
         if (!CheckCode(r)) {
             if (r.status_code == 404)
@@ -371,18 +369,16 @@ void DiscordClient::EditMessage(Snowflake channel_id, Snowflake id, std::string
 
 void DiscordClient::SendLazyLoad(Snowflake id) {
     LazyLoadRequestMessage msg;
-    std::unordered_map<Snowflake, std::vector<std::pair<int, int>>> c;
-    c[id] = {
+    msg.Channels.emplace();
+    msg.Channels.value()[id] = {
         std::make_pair(0, 99),
         std::make_pair(100, 199)
     };
-    msg.Channels = c;
     msg.GuildID = *GetChannel(id)->GuildID;
     msg.ShouldGetActivities = true;
     msg.ShouldGetTyping = true;
 
-    nlohmann::json j = msg;
-    m_websocket.Send(j);
+    m_websocket.Send(msg);
 }
 
 void DiscordClient::JoinGuild(std::string code) {
@@ -477,11 +473,9 @@ void DiscordClient::SetGuildName(Snowflake id, const Glib::ustring &name) {
 void DiscordClient::SetGuildName(Snowflake id, const Glib::ustring &name, sigc::slot<void(bool success)> callback) {
     ModifyGuildObject obj;
     obj.Name = name;
-    sigc::signal<void, bool> signal;
-    signal.connect(callback);
-    m_http.MakePATCH("/guilds/" + std::to_string(id), nlohmann::json(obj).dump(), [this, signal](const http::response_type &r) {
+    m_http.MakePATCH("/guilds/" + std::to_string(id), nlohmann::json(obj).dump(), [this, callback](const http::response_type &r) {
         const auto success = r.status_code == 200;
-        signal.emit(success);
+        callback(success);
     });
 }
 
@@ -492,11 +486,9 @@ void DiscordClient::SetGuildIcon(Snowflake id, const std::string &data) {
 void DiscordClient::SetGuildIcon(Snowflake id, const std::string &data, sigc::slot<void(bool success)> callback) {
     ModifyGuildObject obj;
     obj.IconData = data;
-    sigc::signal<void, bool> signal;
-    signal.connect(callback);
-    m_http.MakePATCH("/guilds/" + std::to_string(id), nlohmann::json(obj).dump(), [this, signal](const http::response_type &r) {
+    m_http.MakePATCH("/guilds/" + std::to_string(id), nlohmann::json(obj).dump(), [this, callback](const http::response_type &r) {
         const auto success = r.status_code == 200;
-        signal.emit(success);
+        callback(success);
     });
 }
 
@@ -505,8 +497,6 @@ void DiscordClient::UnbanUser(Snowflake guild_id, Snowflake user_id) {
 }
 
 void DiscordClient::UnbanUser(Snowflake guild_id, Snowflake user_id, sigc::slot<void(bool success)> callback) {
-    sigc::signal<void, bool> signal;
-    signal.connect(callback);
     m_http.MakeDELETE("/guilds/" + std::to_string(guild_id) + "/bans/" + std::to_string(user_id), [this, callback](const http::response_type &response) {
         callback(response.status_code == 204);
     });
@@ -517,8 +507,6 @@ void DiscordClient::DeleteInvite(const std::string &code) {
 }
 
 void DiscordClient::DeleteInvite(const std::string &code, sigc::slot<void(bool success)> callback) {
-    sigc::signal<void, bool> signal;
-    signal.connect(callback);
     m_http.MakeDELETE("/invites/" + code, [this, callback](const http::response_type &response) {
         callback(CheckCode(response));
     });
@@ -529,8 +517,6 @@ std::vector<BanData> DiscordClient::GetBansInGuild(Snowflake guild_id) {
 }
 
 void DiscordClient::FetchGuildBan(Snowflake guild_id, Snowflake user_id, sigc::slot<void(BanData)> callback) {
-    sigc::signal<void, BanData> signal;
-    signal.connect(callback);
     m_http.MakeGET("/guilds/" + std::to_string(guild_id) + "/bans/" + std::to_string(user_id), [this, callback, guild_id](const http::response_type &response) {
         if (!CheckCode(response)) return;
         auto ban = nlohmann::json::parse(response.text).get<BanData>();
@@ -541,8 +527,6 @@ void DiscordClient::FetchGuildBan(Snowflake guild_id, Snowflake user_id, sigc::s
 }
 
 void DiscordClient::FetchGuildBans(Snowflake guild_id, sigc::slot<void(std::vector<BanData>)> callback) {
-    sigc::signal<void, std::vector<BanData>> signal;
-    signal.connect(callback);
     m_http.MakeGET("/guilds/" + std::to_string(guild_id) + "/bans", [this, callback, guild_id](const http::response_type &response) {
         if (!CheckCode(response)) return;
         auto bans = nlohmann::json::parse(response.text).get<std::vector<BanData>>();
@@ -557,8 +541,6 @@ void DiscordClient::FetchGuildBans(Snowflake guild_id, sigc::slot<void(std::vect
 }
 
 void DiscordClient::FetchGuildInvites(Snowflake guild_id, sigc::slot<void(std::vector<InviteData>)> callback) {
-    sigc::signal<void, std::vector<InviteData>> signal;
-    signal.connect(callback);
     m_http.MakeGET("/guilds/" + std::to_string(guild_id) + "/invites", [this, callback, guild_id](const http::response_type &response) {
         // store?
         if (!CheckCode(response)) return;
@@ -575,8 +557,6 @@ void DiscordClient::FetchGuildInvites(Snowflake guild_id, sigc::slot<void(std::v
 }
 
 void DiscordClient::FetchAuditLog(Snowflake guild_id, sigc::slot<void(AuditLogData)> callback) {
-    sigc::signal<void, AuditLogData> signal;
-    signal.connect(callback);
     m_http.MakeGET("/guilds/" + std::to_string(guild_id) + "/audit-logs", [this, callback](const http::response &response) {
         if (!CheckCode(response)) return;
         auto data = nlohmann::json::parse(response.text).get<AuditLogData>();
@@ -590,6 +570,35 @@ void DiscordClient::FetchAuditLog(Snowflake guild_id, sigc::slot<void(AuditLogDa
     });
 }
 
+void DiscordClient::FetchUserProfile(Snowflake user_id, sigc::slot<void(UserProfileData)> callback) {
+    m_http.MakeGET("/users/" + std::to_string(user_id) + "/profile", [this, callback](const http::response_type &response) {
+        if (!CheckCode(response)) return;
+        callback(nlohmann::json::parse(response.text).get<UserProfileData>());
+    });
+}
+
+void DiscordClient::FetchUserNote(Snowflake user_id, sigc::slot<void(std::string note)> callback) {
+    m_http.MakeGET("/users/@me/notes/" + std::to_string(user_id), [this, callback](const http::response_type &response) {
+        if (response.status_code == 404) return;
+        if (!CheckCode(response)) return;
+        const auto note = nlohmann::json::parse(response.text).get<UserNoteObject>().Note;
+        if (note.has_value())
+            callback(*note);
+    });
+}
+
+void DiscordClient::SetUserNote(Snowflake user_id, std::string note) {
+    SetUserNote(user_id, note, [](auto) {});
+}
+
+void DiscordClient::SetUserNote(Snowflake user_id, std::string note, sigc::slot<void(bool success)> callback) {
+    UserSetNoteObject obj;
+    obj.Note = note;
+    m_http.MakePUT("/users/@me/notes/" + std::to_string(user_id), nlohmann::json(obj).dump(), [this, callback](const http::response_type &response) {
+        callback(response.status_code == 204);
+    });
+}
+
 void DiscordClient::UpdateToken(std::string token) {
     if (!IsStarted()) {
         m_token = token;
@@ -769,6 +778,9 @@ void DiscordClient::HandleGatewayMessage(std::string str) {
                     case GatewayEvent::INVITE_DELETE: {
                         HandleGatewayInviteDelete(m);
                     } break;
+                    case GatewayEvent::USER_NOTE_UPDATE: {
+                        HandleGatewayUserNoteUpdate(m);
+                    } break;
                 }
             } break;
             default:
@@ -1147,6 +1159,11 @@ void DiscordClient::HandleGatewayInviteDelete(const GatewayMessage &msg) {
     m_signal_invite_delete.emit(data);
 }
 
+void DiscordClient::HandleGatewayUserNoteUpdate(const GatewayMessage &msg) {
+    UserNoteUpdateMessage data = msg.Data;
+    m_signal_note_update.emit(data.ID, data.Note);
+}
+
 void DiscordClient::HandleGatewayReconnect(const GatewayMessage &msg) {
     printf("received reconnect\n");
     m_signal_disconnected.emit(true, GatewayCloseCode::Reconnecting);
@@ -1427,6 +1444,7 @@ void DiscordClient::LoadEventMap() {
     m_event_map["GUILD_BAN_ADD"] = GatewayEvent::GUILD_BAN_ADD;
     m_event_map["INVITE_CREATE"] = GatewayEvent::INVITE_CREATE;
     m_event_map["INVITE_DELETE"] = GatewayEvent::INVITE_DELETE;
+    m_event_map["USER_NOTE_UPDATE"] = GatewayEvent::USER_NOTE_UPDATE;
 }
 
 DiscordClient::type_signal_gateway_ready DiscordClient::signal_gateway_ready() {
@@ -1528,3 +1546,7 @@ DiscordClient::type_signal_invite_delete DiscordClient::signal_invite_delete() {
 DiscordClient::type_signal_presence_update DiscordClient::signal_presence_update() {
     return m_signal_presence_update;
 }
+
+DiscordClient::type_signal_note_update DiscordClient::signal_note_update() {
+    return m_signal_note_update;
+}
diff --git a/discord/discord.hpp b/discord/discord.hpp
index d585e39..b973064 100644
--- a/discord/discord.hpp
+++ b/discord/discord.hpp
@@ -130,6 +130,11 @@ public:
 
     void FetchAuditLog(Snowflake guild_id, sigc::slot<void(AuditLogData)> callback);
 
+    void FetchUserProfile(Snowflake user_id, sigc::slot<void(UserProfileData)> callback);
+    void FetchUserNote(Snowflake user_id, sigc::slot<void(std::string note)> callback);
+    void SetUserNote(Snowflake user_id, std::string note);
+    void SetUserNote(Snowflake user_id, std::string note, sigc::slot<void(bool success)> callback);
+
     void UpdateToken(std::string token);
     void SetUserAgent(std::string agent);
 
@@ -172,6 +177,7 @@ private:
     void HandleGatewayGuildBanAdd(const GatewayMessage &msg);
     void HandleGatewayInviteCreate(const GatewayMessage &msg);
     void HandleGatewayInviteDelete(const GatewayMessage &msg);
+    void HandleGatewayUserNoteUpdate(const GatewayMessage &msg);
     void HandleGatewayReconnect(const GatewayMessage &msg);
     void HandleGatewayInvalidSession(const GatewayMessage &msg);
     void HeartbeatThread();
@@ -252,6 +258,7 @@ public:
     typedef sigc::signal<void, InviteData> type_signal_invite_create;
     typedef sigc::signal<void, InviteDeleteObject> type_signal_invite_delete;
     typedef sigc::signal<void, Snowflake, PresenceStatus> type_signal_presence_update;
+    typedef sigc::signal<void, Snowflake, std::string> type_signal_note_update;
     typedef sigc::signal<void, bool, GatewayCloseCode> type_signal_disconnected; // bool true if reconnecting
     typedef sigc::signal<void> type_signal_connected;
 
@@ -278,6 +285,7 @@ public:
     type_signal_invite_create signal_invite_create();
     type_signal_invite_delete signal_invite_delete(); // safe to assume guild id is set
     type_signal_presence_update signal_presence_update();
+    type_signal_note_update signal_note_update();
     type_signal_disconnected signal_disconnected();
     type_signal_connected signal_connected();
 
@@ -305,6 +313,7 @@ protected:
     type_signal_invite_create m_signal_invite_create;
     type_signal_invite_delete m_signal_invite_delete;
     type_signal_presence_update m_signal_presence_update;
+    type_signal_note_update m_signal_note_update;
     type_signal_disconnected m_signal_disconnected;
     type_signal_connected m_signal_connected;
 };
diff --git a/discord/objects.cpp b/discord/objects.cpp
index b08f796..8be697a 100644
--- a/discord/objects.cpp
+++ b/discord/objects.cpp
@@ -74,14 +74,15 @@ void to_json(nlohmann::json &j, const LazyLoadRequestMessage &m) {
     j["op"] = GatewayOp::LazyLoadRequest;
     j["d"] = nlohmann::json::object();
     j["d"]["guild_id"] = m.GuildID;
-    j["d"]["channels"] = nlohmann::json::object();
-    for (const auto &[key, chans] : m.Channels) { // apparently a map gets written as a list
-        j["d"]["channels"][std::to_string(key)] = chans;
+    if (m.Channels.has_value()) {
+        j["d"]["channels"] = nlohmann::json::object();
+        for (const auto &[key, chans] : *m.Channels)
+            j["d"]["channels"][std::to_string(key)] = chans;
     }
     j["d"]["typing"] = m.ShouldGetTyping;
     j["d"]["activities"] = m.ShouldGetActivities;
-    if (m.Members.size() > 0)
-        j["d"]["members"] = m.Members;
+    if (m.Members.has_value())
+        j["d"]["members"] = *m.Members;
 }
 
 void to_json(nlohmann::json &j, const UpdateStatusMessage &m) {
@@ -301,3 +302,38 @@ void from_json(const nlohmann::json &j, InviteDeleteObject &m) {
     JS_O("guild_id", m.GuildID);
     JS_D("code", m.Code);
 }
+
+void from_json(const nlohmann::json &j, ConnectionData &m) {
+    JS_D("id", m.ID);
+    JS_D("type", m.Type);
+    JS_D("name", m.Name);
+    JS_D("verified", m.IsVerified);
+}
+
+void from_json(const nlohmann::json &j, MutualGuildData &m) {
+    JS_D("id", m.ID);
+    JS_ON("nick", m.Nick);
+}
+
+void from_json(const nlohmann::json &j, UserProfileData &m) {
+    JS_D("connected_accounts", m.ConnectedAccounts);
+    JS_D("mutual_guilds", m.MutualGuilds);
+    JS_ON("premium_guild_since", m.PremiumGuildSince);
+    JS_ON("premium_since", m.PremiumSince);
+    JS_D("user", m.User);
+}
+
+void from_json(const nlohmann::json &j, UserNoteObject &m) {
+    JS_ON("note", m.Note);
+    JS_ON("note_user_id", m.NoteUserID);
+    JS_ON("user_id", m.UserID);
+}
+
+void to_json(nlohmann::json &j, UserSetNoteObject &m) {
+    j["note"] = m.Note;
+}
+
+void from_json(const nlohmann::json &j, UserNoteUpdateMessage &m) {
+    JS_D("note", m.Note);
+    JS_D("id", m.ID);
+}
diff --git a/discord/objects.hpp b/discord/objects.hpp
index 0b3e92d..4974131 100644
--- a/discord/objects.hpp
+++ b/discord/objects.hpp
@@ -61,6 +61,7 @@ enum class GatewayEvent : int {
     GUILD_BAN_ADD,
     INVITE_CREATE,
     INVITE_DELETE,
+    USER_NOTE_UPDATE,
 };
 
 enum class GatewayCloseCode : uint16_t {
@@ -170,8 +171,8 @@ struct LazyLoadRequestMessage {
     Snowflake GuildID;
     bool ShouldGetTyping = false;
     bool ShouldGetActivities = false;
-    std::vector<std::string> Members;                                         // snowflake?
-    std::unordered_map<Snowflake, std::vector<std::pair<int, int>>> Channels; // channel ID -> range of sidebar
+    std::optional<std::vector<std::string>> Members;                                         // snowflake?
+    std::optional<std::unordered_map<Snowflake, std::vector<std::pair<int, int>>>> Channels; // channel ID -> range of sidebar
 
     friend void to_json(nlohmann::json &j, const LazyLoadRequestMessage &m);
 };
@@ -424,3 +425,51 @@ struct InviteDeleteObject {
 
     friend void from_json(const nlohmann::json &j, InviteDeleteObject &m);
 };
+
+struct ConnectionData {
+    std::string ID;
+    std::string Type;
+    std::string Name;
+    bool IsVerified;
+
+    friend void from_json(const nlohmann::json &j, ConnectionData &m);
+};
+
+struct MutualGuildData {
+    Snowflake ID;
+    std::optional<std::string> Nick; // null
+
+    friend void from_json(const nlohmann::json &j, MutualGuildData &m);
+};
+
+struct UserProfileData {
+    std::vector<ConnectionData> ConnectedAccounts;
+    std::vector<MutualGuildData> MutualGuilds;
+    std::optional<std::string> PremiumGuildSince; // null
+    std::optional<std::string> PremiumSince;      // null
+    UserData User;
+
+    friend void from_json(const nlohmann::json &j, UserProfileData &m);
+};
+
+struct UserNoteObject {
+    // idk if these can be null or missing but i play it safe
+    std::optional<std::string> Note;
+    std::optional<Snowflake> NoteUserID;
+    std::optional<Snowflake> UserID;
+
+    friend void from_json(const nlohmann::json &j, UserNoteObject &m);
+};
+
+struct UserSetNoteObject {
+    std::string Note;
+
+    friend void to_json(nlohmann::json &j, UserSetNoteObject &m);
+};
+
+struct UserNoteUpdateMessage {
+    std::string Note;
+    Snowflake ID;
+
+    friend void from_json(const nlohmann::json &j, UserNoteUpdateMessage &m);
+};
diff --git a/discord/user.cpp b/discord/user.cpp
index fc7995e..a788b30 100644
--- a/discord/user.cpp
+++ b/discord/user.cpp
@@ -86,3 +86,69 @@ void UserData::update_from_json(const nlohmann::json &j) {
     JS_RD("nsfw_allowed", IsNSFWAllowed);
     JS_RD("phone", Phone);
 }
+
+const char *UserData::GetFlagName(uint64_t flag) {
+    switch (flag) {
+        case DiscordEmployee:
+            return "discordstaff";
+        case PartneredServerOwner:
+            return "partneredowner";
+        case HypeSquadEvents:
+            return "hypesquadevents";
+        case BugHunterLevel1:
+            return "discordbughunter";
+        case HouseBravery:
+            return "hypesquadbravery";
+        case HouseBrilliance:
+            return "hypesquadbrilliance";
+        case HouseBalance:
+            return "hypesquadbalance";
+        case EarlySupporter:
+            return "earlysupporter";
+        case TeamUser:
+            return "teamuser";
+        case System:
+            return "system";
+        case BugHunterLevel2:
+            return "discordbughunter2";
+        case VerifiedBot:
+            return "verifiedbot";
+        case EarlyVerifiedBotDeveloper:
+            return "earlyverifiedbotdeveloper";
+        default:
+            return "unknown";
+    }
+}
+
+const char *UserData::GetFlagReadableName(uint64_t flag) {
+    switch (flag) {
+        case DiscordEmployee:
+            return "Discord Staff";
+        case PartneredServerOwner:
+            return "Partnered Server Owner";
+        case HypeSquadEvents:
+            return "HypeSquad Events";
+        case BugHunterLevel1:
+            return "Discord Bug Hunter";
+        case HouseBravery:
+            return "HypeSquad Bravery";
+        case HouseBrilliance:
+            return "HypeSquad Brilliance";
+        case HouseBalance:
+            return "HypeSquad Balance";
+        case EarlySupporter:
+            return "Early Supporter";
+        case TeamUser:
+            return "Team User"; // ???
+        case System:
+            return "System";
+        case BugHunterLevel2:
+            return "Discord Bug Hunter Level 2";
+        case VerifiedBot:
+            return "Verified Bot";
+        case EarlyVerifiedBotDeveloper:
+            return "Early Verified Bot Developer";
+        default:
+            return "";
+    }
+}
diff --git a/discord/user.hpp b/discord/user.hpp
index 4e6461e..2c216e8 100644
--- a/discord/user.hpp
+++ b/discord/user.hpp
@@ -4,6 +4,27 @@
 #include <string>
 
 struct UserData {
+    enum {
+        DiscordEmployee = 1 << 0,
+        PartneredServerOwner = 1 << 1,
+        HypeSquadEvents = 1 << 2,
+        BugHunterLevel1 = 1 << 3,
+        HouseBravery = 1 << 6,
+        HouseBrilliance = 1 << 7,
+        HouseBalance = 1 << 8,
+        EarlySupporter = 1 << 9,
+        TeamUser = 1 << 10, // no idea what this is
+        System = 1 << 12,
+        BugHunterLevel2 = 1 << 14,
+        VerifiedBot = 1 << 16,
+        EarlyVerifiedBotDeveloper = 1 << 17,
+
+        MaxFlag = EarlyVerifiedBotDeveloper,
+    };
+
+    static const char *GetFlagName(uint64_t flag);
+    static const char *GetFlagReadableName(uint64_t flag);
+
     Snowflake ID;
     std::string Username;
     std::string Discriminator;
@@ -14,9 +35,9 @@ struct UserData {
     std::optional<std::string> Locale;
     std::optional<bool> IsVerified;
     std::optional<std::string> Email; // null
-    std::optional<int> Flags;
+    std::optional<uint64_t> Flags;
     std::optional<int> PremiumType; // null
-    std::optional<int> PublicFlags;
+    std::optional<uint64_t> PublicFlags;
 
     // undocumented (opt)
     std::optional<bool> IsDesktop;