feat: Implement barebones AutoMod support. (#768)

FayeDel · web-flow · commit 9ad859dc3b3e · 2022-06-16T15:32:50.000Z
* docs, feat: Implement barebones AutoMod support.

* feat: Document AutoMod Gateway event(s), intents

* feat: Implement AutoMod HTTP requests.

* docs: Tweak documentation according to ddevs' 88b95ce.

* chore: Remove extra print statement.

* chore: Post localisation space changes (?)

Not sure why this was unstaged on rebase/merge.

* feat: Implement AutoMod Action Metadata as dedicated object.

This also fill out other Automod attribute fields via attrs.

* chore: Resync to latest Discord Automod PR.
diff --git a/interactions/api/http/guild.py b/interactions/api/http/guild.py
@@ -652,3 +652,140 @@ async def get_guild_auditlog(
         return await self._req.request(
             Route("GET", f"/guilds/{guild_id}/audit-logs"), params=payload
         )
+
+    async def list_auto_moderation_rules(self, guild_id: int) -> List[dict]:
+        """
+        Returns a list of all AutoMod rules in a guild.
+        :poram guild_id: Guild ID snowflake.
+        :return: A list of dictionaries containing the automod rules.
+        """
+
+        return await self._req.request(Route("GET", f"/guilds/{guild_id}/auto-moderation/rules"))
+
+    async def get_auto_moderation_rule(self, guild_id: int, rule_id: int) -> dict:
+        """
+        Get a single AutoMod rule in a guild.
+        :param guild_id: Guild ID snowflake.
+        :param rule_id: Rule ID snowflake.
+        :return: A dictionary containing the automod rule.
+        """
+
+        return await self._req.request(
+            Route("GET", f"/guilds/{guild_id}/auto-moderation/rules/{rule_id}")
+        )
+
+    async def create_auto_moderation_rule(
+        self,
+        guild_id: int,
+        name: str,
+        event_type: int,
+        trigger_type: int,
+        actions: List[dict],
+        trigger_metadata: Optional[dict] = None,
+        enabled: Optional[bool] = False,
+        exempt_roles: Optional[List[str]] = None,
+        exempt_channels: Optional[List[str]] = None,
+        reason: Optional[str] = None,
+    ) -> dict:
+        """
+        Create a new AutoMod rule in a guild.
+
+        :param guild_id: Guild ID snowflake.
+        :param name: The name of the new rule.
+        :param event_type: The event type of the new rule.
+        :param trigger_type: The trigger type of the new rule.
+        :param trigger_metadata: The trigger metadata payload representation. This can be omitted based on the trigger type.
+        :param actions: The actions that will execute when the rule is triggered.
+        :param enabled: Whether the rule will be enabled upon creation. False by default.
+        :param exempt_roles: The role IDs that are whitelisted by the rule, if given. The maximum is 20.
+        :param exempt_channels: The channel IDs that are whitelisted by the rule, if given. The maximum is 20
+        :param reason: Reason to send to audit log, if any.
+        :return: A dictionary containing the new automod rule.
+        """
+
+        params = {
+            "name": name,
+            "event_type": event_type,
+            "trigger_type": trigger_type,
+            "actions": actions,
+            "enabled": enabled,
+        }
+        if trigger_metadata:
+            params["trigger_metadata"] = trigger_metadata
+        if exempt_roles:
+            params["exempt_roles"] = exempt_roles
+        if exempt_channels:
+            params["exempt_channels"] = exempt_channels
+
+        return await self._req.request(
+            Route(
+                "POST", f"/guilds/{guild_id}/auto-moderation/rules/", params=params, reason=reason
+            )
+        )
+
+    async def modify_auto_moderation_rule(
+        self,
+        guild_id: int,
+        rule_id: int,
+        name: Optional[str] = None,
+        event_type: Optional[int] = None,
+        trigger_metadata: Optional[dict] = None,
+        actions: Optional[List[dict]] = None,
+        enabled: Optional[bool] = None,
+        exempt_roles: Optional[List[str]] = None,
+        exempt_channels: Optional[List[str]] = None,
+        reason: Optional[str] = None,
+    ) -> dict:
+        """
+        Modify an existing AutoMod rule in a guild.
+
+        .. note ::
+            All parameters besides guild and rule ID are optional.
+
+        :param guild_id: Guild ID snowflake.
+        :param rule_id: Rule ID snowflake.
+        :param name: The new name of the rule.
+        :param event_type: The new event type of the rule.
+        :param trigger_metadata: The new trigger metadata payload representation. This can be omitted based on the trigger type.
+        :param actions: The new actions that will execute when the rule is triggered.
+        :param enabled: Whether the rule will be enabled upon creation.
+        :param exempt_roles: The role IDs that are whitelisted by the rule, if given. The maximum is 20.
+        :param exempt_channels: The channel IDs that are whitelisted by the rule, if given. The maximum is 20
+        :param reason: Reason to send to audit log, if any.
+        :return: A dictionary containing the updated automod rule.
+        """
+        payload = {}
+        if name:
+            payload["name"] = name
+        if event_type:
+            payload["event_type"] = event_type
+        if trigger_metadata:
+            payload["trigger_metadata"] = trigger_metadata
+        if actions:
+            payload["actions"] = actions
+        if enabled:
+            payload["enabled"] = enabled
+        if exempt_roles:
+            payload["exempt_roles"] = exempt_roles
+        if exempt_channels:
+            payload["exempt_channels"] = exempt_channels
+
+        return await self._req.request(
+            Route("PATCH", f"/guilds/{guild_id}/auto-moderation/rules/{rule_id}"),
+            json=payload,
+            reason=reason,
+        )
+
+    async def delete_auto_moderation_rule(
+        self, guild_id: int, rule_id: int, reason: Optional[str] = None
+    ) -> None:
+        """
+        Deletes an AutoMod rule.
+        :param guild_id: Guild ID snowflake.
+        :param rule_id: Rule ID snowflake.
+        :param reason: Reason to send to audit log, if any.
+        """
+
+        return await self._req.request(
+            Route("DELETE", f"/guilds/{guild_id}/auto-moderation/rules/{rule_id}"), reason=reason
+        )
diff --git a/interactions/api/http/guild.pyi b/interactions/api/http/guild.pyi
@@ -115,3 +115,37 @@ class GuildRequest:
         before: Optional[int] = None,
         limit: int = 50,
     ) -> dict: ...
+
+    async def list_auto_moderation_rules(self, guild_id: int) -> List[dict]: ...
+
+    async def get_auto_moderation_rule(self, guild_id: int, rule_id: int) -> dict: ...
+
+    async def create_auto_moderation_rule(
+            self,
+            guild_id: int,
+            name: str,
+            event_type: int,
+            trigger_type: int,
+            actions: List[dict],
+            trigger_metadata: Optional[dict] = None,
+            enabled: Optional[bool] = False,
+            exempt_roles: Optional[List[str]] = None,
+            exempt_channels: Optional[List[str]] = None,
+            reason: Optional[str] = None,
+    ) -> dict: ...
+
+    async def modify_auto_moderation_rule(
+            self,
+            guild_id: int,
+            rule_id: int,
+            name: Optional[str] = None,
+            event_type: Optional[int] = None,
+            trigger_metadata: Optional[dict] = None,
+            actions: Optional[List[dict]] = None,
+            enabled: Optional[bool] = None,
+            exempt_roles: Optional[List[str]] = None,
+            exempt_channels: Optional[List[str]] = None,
+            reason: Optional[str] = None
+    ) -> dict: ...
+
+    async def delete_auto_moderation_rule(self, guild_id: int, rule_id: int, reason: Optional[str] = None) -> None: ...
diff --git a/interactions/api/http/invite.py b/interactions/api/http/invite.py
@@ -22,9 +22,9 @@ async def get_invite(
         guild_scheduled_event_id: int = None,
     ) -> dict:
         """
-        Gets an invite using its code.
+        Gets a Discord invite using its code.
 
-                .. note:: with_expiration is currently broken, the API will always return expiration_date.
+        .. note:: with_expiration is currently broken, the API will always return expiration_date.
 
         :param invite_code: A string representing the invite code.
         :param with_counts: Whether approximate_member_count and approximate_presence_count are returned.
@@ -48,8 +48,8 @@ async def delete_invite(self, invite_code: str, reason: Optional[str] = None) ->
         """
         Delete an invite.
 
-        :param invite_code: The code of the invite to delete
+        :param invite_code: The code of the invite to delete.
         :param reason: Reason to show in the audit log, if any.
-        :return: The deleted invite object
+        :return: The deleted invite object.
         """
         return await self._req.request(Route("DELETE", f"/invites/{invite_code}"), reason=reason)
diff --git a/interactions/api/models/flags.py b/interactions/api/models/flags.py
@@ -23,6 +23,8 @@ class Intents(IntFlag):
     DIRECT_MESSAGE_TYPING = 1 << 14
     GUILD_MESSAGE_CONTENT = 1 << 15
     GUILD_SCHEDULED_EVENTS = 1 << 16
+    AUTO_MODERATION_CONFIGURATION = 1 << 20
+    AUTO_MODERATION_EXECUTION = 1 << 21
 
     PRIVILEGED = GUILD_PRESENCES | GUILD_MEMBERS | GUILD_MESSAGE_CONTENT
     DEFAULT = (
@@ -40,6 +42,8 @@ class Intents(IntFlag):
         | DIRECT_MESSAGE_REACTIONS
         | DIRECT_MESSAGE_TYPING
         | GUILD_SCHEDULED_EVENTS
+        | AUTO_MODERATION_CONFIGURATION
+        | AUTO_MODERATION_EXECUTION
     )
     ALL = DEFAULT | PRIVILEGED
 
diff --git a/interactions/api/models/gw.py b/interactions/api/models/gw.py
@@ -15,13 +15,15 @@
 from .guild import EventMetadata
 from .member import Member
 from .message import Embed, Emoji, Message, MessageInteraction, Sticker
-from .misc import ClientStatus, File, Snowflake
+from .misc import AutoModAction, AutoModTriggerMetadata, ClientStatus, File, Snowflake
 from .presence import PresenceActivity
 from .role import Role
 from .team import Application
 from .user import User
 
 __all__ = (
+    "AutoModerationAction",
+    "AutoModerationRule",
     "ApplicationCommandPermissions",
     "EmbeddedActivity",
     "Integration",
@@ -45,6 +47,72 @@
 )
 
 
+@define()
+class AutoModerationAction(DictSerializerMixin):
+    """
+    A class object representing the gateway event ``AUTO_MODERATION_ACTION_EXECUTION``.
+
+    :ivar Snowflake guild_id: The ID of the guild in which the action was executed.
+    :ivar AutoModAction action: The action which was executed.
+    :ivar Snowflake rule_id: The rule ID that the action belongs to.
+    :ivar int rule_trigger_type: The trigger rule type.
+    :ivar Optional[Snowflake] channel_id: The id of the channel in which user content was posted.
+    :ivar Optional[Snowflake] message_id: The id of any user message which content belongs to.
+    :ivar Optional[Snowflake] alert_system_message_id: The id of any system automoderation messages posted as a result of this action.
+    :ivar str content: The user-generated text content in question.
+    :ivar Optional[str] matched_keyword: The word/phrase configured in rule that triggered rule.
+    :ivar Optional[str] matched_content: The substring in content that triggered rule.
+    """
+
+    guild_id: Snowflake = field(converter=Snowflake)
+    action: AutoModAction = field(converter=AutoModAction)
+    rule_id: Snowflake = field(converter=Snowflake)
+    rule_trigger_type: int = field()
+    channel_id: Optional[Snowflake] = field(converter=Snowflake, default=None)
+    message_id: Optional[Snowflake] = field(converter=Snowflake, default=None)
+    alert_system_message_id: Optional[Snowflake] = field(converter=Snowflake, default=None)
+    content: str = field()
+    matched_keyword: Optional[str] = field(default=None)
+    matched_content: Optional[str] = field(default=None)
+
+
+@define()
+class AutoModerationRule(DictSerializerMixin):
+    """
+    A class object representing the gateway events ``AUTO_MODERATION_RULE_CREATE``, ``AUTO_MODERATION_RULE_UPDATE``, and ``AUTO_MODERATION_RULE_DELETE``
+
+    .. note::
+        This is undocumented by the Discord API, so these attribute docs may or may not be finalised.
+
+    .. note::
+        ``event_type`` at the moment is only ``1``, which represents message sending.
+
+    :ivar Snowflake id: The ID of the rule.
+    :ivar Snowflake guild_id: The guild ID associated with the rule.
+    :ivar str name: The rule name.
+    :ivar Snowflake creator_id: The user ID that first created this rule.
+    :ivar int event_type: The rule type in which automod checks.
+    :ivar int trigger_type: The automod type. It characterises what type of information that is checked.
+    :ivar Dict[str, List[str]] trigger_metadata: Additional data needed to figure out whether this rule should be triggered.
+    :ivar List[AutoModerationAction] actions: The actions that will be executed when the rule is triggered.
+    :ivar bool enabled: Whether the rule is enabled.
+    :ivar List[Snowflake] exempt_roles: The role IDs that should not be affected by this rule. (Max 20)
+    :ivar List[Snowflake] exempt_channels: The channel IDs that should not be affected by this rule. (Max 20)
+    """
+
+    id: Snowflake = field(converter=Snowflake)
+    guild_id: Snowflake = field(converter=Snowflake)
+    name: str = field()
+    creator_id: Snowflake = field(converter=Snowflake)
+    event_type: int = field()
+    trigger_type: str = field()
+    trigger_metadata: AutoModTriggerMetadata = field(converter=AutoModTriggerMetadata)
+    actions: List[AutoModAction] = field(converter=convert_list(AutoModAction))
+    enabled: bool = field()
+    exempt_roles: List[Snowflake] = field(converter=convert_list(Snowflake))
+    exempt_channels: List[Snowflake] = field(converter=convert_list(Snowflake))
+
+
 @define()
 class ApplicationCommandPermissions(ClientSerializerMixin):
     """
diff --git a/interactions/api/models/gw.pyi b/interactions/api/models/gw.pyi
@@ -1,18 +1,46 @@
 from datetime import datetime
-from typing import Any, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from ...client.models.component import ActionRow, Button, SelectMenu
 from .attrs_utils import ClientSerializerMixin, DictSerializerMixin, define
 from .channel import Channel, ThreadMember
 from .guild import EventMetadata
 from .member import Member
 from .message import Embed, Emoji, Message, MessageInteraction, Sticker
-from .misc import ClientStatus, File, Snowflake
+from .misc import AutoModAction, ClientStatus, File, Snowflake, AutoModTriggerMetadata
 from .presence import PresenceActivity
 from .role import Role
 from .team import Application
 from .user import User
 
+
+class AutoModerationAction(DictSerializerMixin):
+    guild_id: Snowflake
+    action: AutoModAction
+    rule_id: Snowflake
+    rule_trigger_type: int
+    channel_id: Optional[Snowflake]
+    message_id: Optional[Snowflake]
+    alert_system_message_id: Optional[Snowflake]
+    content: str
+    matched_keyword: Optional[str]
+    matched_content: Optional[str]
+
+class AutoModerationRule(DictSerializerMixin):
+    _json: dict
+    id: Snowflake
+    guild_id: Snowflake
+    name: str
+    creator_id: str
+    event_type: int
+    trigger_type: int
+    trigger_metadata: AutoModTriggerMetadata
+    actions: List[AutoModAction]
+    enabled: bool
+    exempt_roles: List[Snowflake]
+    exempt_channels: List[Snowflake]
+
+
 @define()
 class ApplicationCommandPermissions(ClientSerializerMixin):
     application_id: Snowflake
diff --git a/interactions/api/models/message.py b/interactions/api/models/message.py
@@ -70,6 +70,7 @@ class MessageType(IntEnum):
     THREAD_STARTER_MESSAGE = 21
     GUILD_INVITE_REMINDER = 22
     CONTEXT_MENU_COMMAND = 23
+    AUTO_MODERATION_ACTION = 24
 
 
 @define()
diff --git a/interactions/api/models/misc.py b/interactions/api/models/misc.py
diff --git a/interactions/api/models/misc.pyi b/interactions/api/models/misc.pyi
diff --git a/interactions/client/models/command.py b/interactions/client/models/command.py
