implement functions to add/remove roles from members

Author: Arkrissym

Discord.C++/ApplicationCommand.h

@@ -110,6 +110,6 @@ class ApplicationCommand : public DiscordObject {
     /// Add interaction context where the command can be used.
     DLL_EXPORT void add_contexts(ContextType context) { contexts.push_back(context); }
     /// Set the handler type for PRIMARY_ENTRY_POINT.
-    DLL_EXPORT void get_handler(HandlerType handler) { this->handler.emplace(handler); }
+    DLL_EXPORT void set_handler(HandlerType handler) { this->handler.emplace(handler); }
 };
 }  // namespace DiscordCPP

Discord.C++/Interaction.cpp

@@ -8,10 +8,10 @@ DiscordCPP::Interaction::Interaction(const json& data, const std::string& token)
       type(static_cast<Type>(data.at("type").get<int>())) {
     data.at("application_id").get_to<std::string>(application_id);
 
+    guild_id = get_optional<std::string>(data, "guild_id");
     if (has_value(data, "data")) {
-        this->data.emplace(data.at("data"), token);
+        this->data.emplace(data.at("data"), token, guild_id.value_or(""));
     }
-    guild_id = get_optional<std::string>(data, "guild_id");
     channel_id = get_optional<std::string>(data, "channel_id");
     if (has_value(data, "member")) {
         member.emplace(data.at("member"), token);

Discord.C++/InteractionData.cpp

@@ -1,6 +1,6 @@
 #include "InteractionData.h"
 
-DiscordCPP::InteractionData::InteractionData(const json& data, const std::string& token)
+DiscordCPP::InteractionData::InteractionData(const json& data, const std::string& token, const std::string& guild_id)
     : DiscordCPP::DiscordObject(token, data.at("id").get<std::string>()),
       name(data.at("name").get<std::string>()),
       type(static_cast<ApplicationCommand::Type>(data.at("type").get<int>())) {
@@ -9,9 +9,8 @@ DiscordCPP::InteractionData::InteractionData(const json& data, const std::string
             options.push_back(InteractionDataOptionHelper::interaction_data_option_from_json(option));
         }
     }
-    guild_id = get_optional<std::string>(data, "guild_id");
     if (has_value(data, "resolved")) {
-        resolved_data = InteractionResolvedData(data.at("resolved"), guild_id.value_or(""), token);
+        resolved_data = InteractionResolvedData(data.at("resolved"), guild_id, token);
     }
     custom_id = get_optional<std::string>(data, "custom_id");
     target_id = get_optional<std::string>(data, "target_id");

Discord.C++/InteractionData.h

@@ -19,8 +19,6 @@ class InteractionData : public DiscordObject {
     std::optional<InteractionResolvedData> resolved_data;
     /// The parameters and values from the user.
     std::vector<InteractionDataOptionVariant> options;
-    /// The id of the guild the command is registered to.
-    std::optional<std::string> guild_id;
     /// Id the of user or message targeted by a user or message command.
     std::optional<std::string> target_id;
     /// The custom id of the component.
@@ -30,7 +28,7 @@ class InteractionData : public DiscordObject {
     // components
 
    public:
-    DLL_EXPORT InteractionData(const json& data, const std::string& token);
+    DLL_EXPORT InteractionData(const json& data, const std::string& token, const std::string& guild_id);
 
     /// @return name of the invoked command.
     DLL_EXPORT std::string get_name() { return name; }
@@ -40,8 +38,6 @@ class InteractionData : public DiscordObject {
     DLL_EXPORT std::optional<InteractionResolvedData> get_resolved_data() { return resolved_data; }
     /// @return The parameters and values from the user.
     DLL_EXPORT std::vector<InteractionDataOptionVariant> get_options() { return options; }
-    /// @return The id of the guild the command is registered to.
-    DLL_EXPORT std::optional<std::string> get_guild_id() { return guild_id; }
     /// @return Id the of user or message targeted by a user or message command.
     DLL_EXPORT std::optional<std::string> get_target_id() { return target_id; }
     /// @return The custom id of the component.

Discord.C++/InteractionResolvedData.cpp

@@ -11,7 +11,9 @@ DiscordCPP::InteractionResolvedData::InteractionResolvedData(const json& data, c
 
     if (has_value(data, "members")) {
         for (auto [key, value] : data["members"].items()) {
-            members.insert(std::make_pair(key, Member(value, token)));
+            json member_json = value;
+            member_json["user"] = data["users"][key];
+            members.insert(std::make_pair(key, Member(member_json, token)));
         }
     }
 

Discord.C++/Member.cpp

@@ -18,3 +18,25 @@ DiscordCPP::Member::operator std::string() {
     else
         return nick;
 }
+
+void DiscordCPP::Member::add_role(const DiscordCPP::Role& role) {
+    std::string url = "/guilds/" + role.get_guild_id() + "/members/" + get_id();
+
+    role_ids.push_back(role.get_id());
+    json data = {{"roles", role_ids}};
+
+    api_call(url, "PATCH", data, "application/json", false);
+}
+
+void DiscordCPP::Member::remove_role(const DiscordCPP::Role& role) {
+    std::string url = "/guilds/" + role.get_guild_id() + "/members/" + get_id();
+
+    role_ids.erase(std::remove_if(role_ids.begin(),
+                                  role_ids.end(),
+                                  [role](std::string i) {
+                                      return role.get_id() == i;
+                                  }));
+    json data = {{"roles", role_ids}};
+
+    api_call(url, "PATCH", data, "application/json", false);
+}

Discord.C++/Member.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "Role.h"
 #include "User.h"
 #include "static.h"
 
@@ -22,6 +23,13 @@ class Member : public User {
     DLL_EXPORT Member(const json& data, const std::string& token);
     DLL_EXPORT Member() = default;
 
+    /** Assign the given role to this member.
+        @param[in] role the role to assign */
+    DLL_EXPORT void add_role(const Role& role);
+    /** Remove the given role from this member.
+        @param[in] role the role to remove */
+    DLL_EXPORT void remove_role(const Role& role);
+
     ///@return Nickname (Username if not present) as std::string
     DLL_EXPORT explicit operator std::string() override;
 

Discord.C++/Role.h

@@ -44,6 +44,8 @@ class Role : public DiscordObject {
      */
     DLL_EXPORT void delete_role();
 
+    /// @return the role's guild id
+    DLL_EXPORT std::string get_guild_id() const { return guild_id; }
     /// @return role name
     DLL_EXPORT std::string get_name() const { return name; }
     /// @return integer representation of hexadecimal color code
@@ -65,8 +67,7 @@ class Role : public DiscordObject {
     /// @return role flags combined as a bitfield
     DLL_EXPORT int get_flags() const { return flags; }
     /** @param[in] flag the Flag to check
-     *	@return true if the role has the given flag
-     */
+     *	@return true if the role has the given flag */
     DLL_EXPORT bool has_flag(Flag flag) const { return flags & flag; }
 };
 }  // namespace DiscordCPP

Discord.C++/User.h

@@ -1,5 +1,4 @@
 #pragma once
-#include <iostream>
 
 #include "DiscordObject.h"
 #include "Logger.h"

test_bot/main.cpp

@@ -113,6 +113,38 @@ class Client : public Discord {
         permissions.add_integration_types(DiscordCPP::ApplicationCommand::GUILD_INSTALL);
         create_application_command(permissions);
 
+        ApplicationCommand role_cmd;
+        role_cmd.set_name("role");
+        role_cmd.set_description("add/remove roles from a member");
+        role_cmd.set_type(DiscordCPP::ApplicationCommand::CHAT_INPUT);
+        role_cmd.add_contexts(DiscordCPP::ApplicationCommand::GUILD);
+        role_cmd.add_integration_types(DiscordCPP::ApplicationCommand::GUILD_INSTALL);
+        ApplicationCommandValueOption member;
+        member.set_type(DiscordCPP::ApplicationCommandOption::USER);
+        member.set_name("member");
+        member.set_description("member");
+        member.set_required(true);
+        ApplicationCommandValueOption role;
+        role.set_type(DiscordCPP::ApplicationCommandOption::ROLE);
+        role.set_name("role");
+        role.set_description("role");
+        role.set_required(true);
+        ApplicationCommandSubcommand add;
+        add.set_type(DiscordCPP::ApplicationCommandOption::SUB_COMMAND);
+        add.set_name("add");
+        add.set_description("assign role to member");
+        add.add_option(member);
+        add.add_option(role);
+        ApplicationCommandSubcommand remove;
+        remove.set_type(DiscordCPP::ApplicationCommandOption::SUB_COMMAND);
+        remove.set_name("remove");
+        remove.set_description("remove role from member");
+        remove.add_option(member);
+        remove.add_option(role);
+        role_cmd.add_option(add);
+        role_cmd.add_option(remove);
+        create_application_command(role_cmd);
+
         update_presence(DiscordStatus::Online, Activity("test", Activity::Type::Game));
     }
 
@@ -481,6 +513,19 @@ class Client : public Discord {
                                   + "\nYou are " + std::string(can_delete_messages ? "" : "not ") + "allowed to delete messages"  //
                                   + "\nYou can " + std::string(can_kick_members ? "" : "not ") + "kick members");
             }
+        } else if (name == "role") {
+            auto options = interaction.get_data().value().get_options();
+            auto member = interaction.get_data()->get_resolved_data()->get_members().begin()->second;
+            auto role = interaction.get_data()->get_resolved_data()->get_roles().begin()->second;
+            for (auto& option : options) {
+                if (InteractionDataOptionHelper::get_interaction_data_option_name(option) == "add" && InteractionDataOptionHelper::get_interaction_data_option_type(option) == ApplicationCommandOption::Type::SUB_COMMAND) {
+                    member.add_role(role);
+                    interaction.reply("role " + role.get_name() + " assigned to " + std::string(member));
+                } else if (InteractionDataOptionHelper::get_interaction_data_option_name(option) == "remove" && InteractionDataOptionHelper::get_interaction_data_option_type(option) == ApplicationCommandOption::Type::SUB_COMMAND) {
+                    member.remove_role(role);
+                    interaction.reply("role " + role.get_name() + " removed from " + std::string(member));
+                }
+            }
         }
     }