Add Application Permissions Support

discord_slash/cog_ext.py

@@ -1,6 +1,6 @@
 import typing
 import inspect
-from .model import CogCommandObject, CogSubcommandObject
+from .model import CogBaseCommandObject, CogSubcommandObject
 from .utils import manage_commands
 
 
@@ -9,6 +9,8 @@ def cog_slash(*,
               description: str = None,
               guild_ids: typing.List[int] = None,
               options: typing.List[dict] = None,
+              default_permission: bool = True,
+              permissions: dict = None,
               connector: dict = None):
     """
     Decorator for Cog to add slash command.\n
@@ -34,6 +36,10 @@ async def ping(self, ctx: SlashContext):
     :type guild_ids: List[int]
     :param options: Options of the slash command. This will affect ``auto_convert`` and command data at Discord API. Default ``None``.
     :type options: List[dict]
+    :param default_permission: Sets if users have permission to run slash command by default, when no permissions are set. Default ``True``.
+    :type default_permission: bool
+    :param permissions: Permission requirements of the slash command. Default ``None``.
+    :type permissions: dict
     :param connector: Kwargs connector for the command. Default ``None``.
     :type connector: dict
     """
@@ -49,10 +55,12 @@ def wrapper(cmd):
             "description": desc,
             "guild_ids": guild_ids,
             "api_options": opts,
+            "default_permission": default_permission,
+            "api_permissions": permissions,
             "connector": connector,
             "has_subcommands": False
         }
-        return CogCommandObject(name or cmd.__name__, _cmd)
+        return CogBaseCommandObject(name or cmd.__name__, _cmd)
     return wrapper
 
 
@@ -63,6 +71,8 @@ def cog_subcommand(*,
                    description: str = None,
                    base_description: str = None,
                    base_desc: str = None,
+                   base_default_permission: bool = True,
+                   base_permissions: dict = None,
                    subcommand_group_description: str = None,
                    sub_group_desc: str = None,
                    guild_ids: typing.List[int] = None,
@@ -95,6 +105,10 @@ async def group_say(self, ctx: SlashContext, text: str):
     :param base_description: Description of the base command. Default ``None``.
     :type base_description: str
     :param base_desc: Alias of ``base_description``.
+    :param base_default_permission: Sets if users have permission to run slash command by default, when no permissions are set. Default ``True``.
+    :type base_default_permission: bool
+    :param base_permissions: Permission requirements of the slash command. Default ``None``.
+    :type base_permissions: dict
     :param subcommand_group_description: Description of the subcommand_group. Default ``None``.
     :type subcommand_group_description: str
     :param sub_group_desc: Alias of ``subcommand_group_description``.
@@ -107,6 +121,7 @@ async def group_say(self, ctx: SlashContext, text: str):
     """
     base_description = base_description or base_desc
     subcommand_group_description = subcommand_group_description or sub_group_desc
+    guild_ids = guild_ids if guild_ids else []
 
     def wrapper(cmd):
         desc = description or inspect.getdoc(cmd)
@@ -115,6 +130,17 @@ def wrapper(cmd):
         else:
             opts = options
 
+        _cmd = {
+            "func": None,
+            "description": base_description,
+            "guild_ids": guild_ids.copy(),
+            "api_options": [],
+            "default_permission": base_default_permission,
+            "api_permissions": base_permissions,
+            "connector": {},
+            "has_subcommands": True
+        }
+
         _sub = {
             "func": cmd,
             "name": name or cmd.__name__,
@@ -125,5 +151,5 @@ def wrapper(cmd):
             "api_options": opts,
             "connector": connector
         }
-        return CogSubcommandObject(_sub, base, name or cmd.__name__, subcommand_group)
+        return CogSubcommandObject(base, _cmd, subcommand_group, name or cmd.__name__, _sub)
     return wrapper

discord_slash/http.py

@@ -54,6 +54,24 @@ def get_all_commands(self, guild_id=None):
         """
         return self.command_request(method="GET", guild_id=guild_id)
 
+    def get_all_guild_commands_permissions(self, guild_id):
+        """
+        Sends a slash command get request to Discord API for all permissions of a guild.
+
+        :param guild_id: ID of the target guild to get registered command permissions of.
+        :return: JSON Response of the request.
+        """
+        return self.command_request(method="GET", guild_id=guild_id, url_ending="/permissions")
+
+    def update_guild_commands_permissions(self, guild_id, perms_dict):
+        """
+        Sends a slash command put request to the Discord API for setting all command permissions of a guild.
+
+        :param guild_id: ID of the target guild to register command permissions.
+        :return: JSON Response of the request.
+        """
+        return self.command_request(method="PUT", guild_id=guild_id, json=perms_dict, url_ending="/permissions")
+
     def add_slash_command(
         self, guild_id, cmd_name: str, description: str, options: list = None
     ):
@@ -167,4 +185,3 @@ def delete(self, token, message_id="@original"):
         """
         req_url = f"/messages/{message_id}"
         return self.command_response(token, True, "DELETE", url_ending = req_url)
-

discord_slash/model.py

@@ -123,7 +123,6 @@ def __init__(self, name, cmd):  # Let's reuse old command formatting.
         self.allowed_guild_ids = cmd["guild_ids"] or []
         self.options = cmd["api_options"] or []
         self.connector = cmd["connector"] or {}
-        self.has_subcommands = cmd["has_subcommands"]
         # Ref https://github.com/Rapptz/discord.py/blob/master/discord/ext/commands/core.py#L1447
         # Since this isn't inherited from `discord.ext.commands.Command`, discord.py's check decorator will
         # add checks at this var.
@@ -176,6 +175,28 @@ async def can_run(self, ctx) -> bool:
         return False not in res
 
 
+class BaseCommandObject(CommandObject):
+    """
+    BaseCommand object of this extension.
+
+    .. note::
+        This model inherits :class:`.model.CommandObject`, so this has every variables from that.
+
+    .. warning::
+        Do not manually init this model.
+
+    :ivar has_subcommands: Indicates whether this base command has subcommands.
+    :ivar default_permission: Indicates whether users should have permissions to run this command by default.
+    :ivar permissions: Permissions to restrict use of this command.
+    """
+
+    def __init__(self, name, cmd):  # Let's reuse old command formatting.
+        super().__init__(name, cmd)
+        self.has_subcommands = cmd["has_subcommands"]
+        self.default_permission = cmd["default_permission"]
+        self.permissions = cmd["api_permissions"] or []
+
+
 class SubcommandObject(CommandObject):
     """
     Subcommand object of this extension.
@@ -193,15 +214,14 @@ class SubcommandObject(CommandObject):
     """
 
     def __init__(self, sub, base, name, sub_group=None):
-        sub["has_subcommands"] = True  # For the inherited class.
         super().__init__(name, sub)
         self.base = base.lower()
         self.subcommand_group = sub_group.lower() if sub_group else sub_group
         self.base_description = sub["base_desc"]
         self.subcommand_group_description = sub["sub_group_desc"]
 
 
-class CogCommandObject(CommandObject):
+class CogBaseCommandObject(BaseCommandObject):
     """
     Slash command object but for Cog.
 
@@ -235,8 +255,9 @@ class CogSubcommandObject(SubcommandObject):
         Do not manually init this model.
     """
 
-    def __init__(self, *args):
-        super().__init__(*args)
+    def __init__(self, base, cmd, sub_group, name, sub):
+        super().__init__(sub, base, name, sub_group)
+        self.base_command_data = cmd
         self.cog = None  # Manually set this later.
 
     async def invoke(self, *args, **kwargs):
@@ -358,3 +379,67 @@ async def wrap():
                     await self._http.delete(self.__interaction_token, self.id)
 
             self._state.loop.create_task(wrap())
+
+
+class PermissionData:
+    """
+    Single slash permission data.
+
+    :ivar id: User or role id, based on following type specfic.
+    :ivar type: The ``SlashCommandPermissionsType`` type of this permission.
+    :ivar permission: State of permission. ``True`` to allow, ``False`` to disallow.
+    """
+    def __init__(self, id, type, permission, **kwargs):
+        self.id = id
+        self.type = type
+        self.permission = permission
+
+    def __eq__(self, other):
+        if isinstance(other, PermissionData):
+            return (
+                self.id == other.id
+                and self.type == other.id
+                and self.permission == other.permission
+            )
+        else:
+            return False
+
+
+class GuildPermissionsData:
+    """
+    Slash permissions data for a command in a guild.
+
+    :ivar id: Command id, provided by discord.
+    :ivar guild_id: Guild id that the permissions are in. 
+    :ivar permissions: List of permissions dict.
+    """
+    def __init__(self, id, guild_id, permissions, **kwargs):
+        self.id = id
+        self.guild_id = guild_id
+        self.permissions = []
+        if permissions:
+            for permission in permissions:
+                self.permissions.append(PermissionData(**permission))
+
+    def __eq__(self, other):
+        if isinstance(other, GuildPermissionsData):
+            return (
+                self.id == other.id
+                and self.guild_id == other.guild_id
+                and self.permissions == other.permissions
+            )
+        else:
+            return False
+
+
+class SlashCommandPermissionType(IntEnum):
+    """
+    Equivalent of `ApplicationCommandPermissionType <https://discord.com/developers/docs/interactions/slash-commands#applicationcommandpermissiontype>`_  in the Discord API.
+    """
+    ROLE = 1
+    USER = 2
+
+    @classmethod
+    def from_type(cls, t: type):
+        if issubclass(t, discord.abc.Role): return cls.ROLE
+        if issubclass(t, discord.abc.User): return cls.USER