Merge branch 'main' into aoc-slash-commands

Author: Robin5605

bot/exts/advent_of_code/_cog.py

@@ -22,7 +22,7 @@
 from bot.exts.advent_of_code import _helpers
 from bot.exts.advent_of_code.views.dayandstarview import AoCDropdownView
 from bot.utils import members
-from bot.utils.decorators import InChannelCheckFailure, in_month, whitelist_override, with_role
+from bot.utils.decorators import in_month, in_whitelist, with_role
 
 log = logging.getLogger(__name__)
 
@@ -34,6 +34,8 @@
 # They aren't spammy and foster discussion
 AOC_WHITELIST = AOC_WHITELIST_RESTRICTED + (Channels.advent_of_code,)
 
+AOC_REDIRECT = (Channels.advent_of_code_commands, Channels.sir_lancebot_playground, Channels.bot_commands)
+
 
 class AdventOfCode(commands.Cog):
     """Advent of Code festivities! Ho Ho Ho!"""
@@ -133,7 +135,7 @@ async def adventofcode_group(self, ctx: commands.Context) -> None:
         if not ctx.invoked_subcommand:
             await self.bot.invoke_help_command(ctx)
 
-    @with_role(Roles.admins)
+    @with_role(Roles.admins, fail_silently=True)
     @adventofcode_group.command(
         name="block",
         brief="Block a user from getting the completionist role.",
@@ -148,7 +150,7 @@ async def block_from_role(self, ctx: commands.Context, member: discord.Member) -
         await ctx.send(f":+1: Blocked {member.mention} from getting the AoC completionist role.")
 
     @adventofcode_group.command(name="countdown", aliases=("count", "c"), brief="Return time left until next day")
-    @whitelist_override(channels=AOC_WHITELIST)
+    @in_whitelist(channels=AOC_WHITELIST, redirect=AOC_REDIRECT)
     async def aoc_countdown(self, ctx: commands.Context) -> None:
         """Return time left until next day."""
         if _helpers.is_in_advent():
@@ -167,13 +169,13 @@ async def aoc_countdown(self, ctx: commands.Context) -> None:
         )
 
     @adventofcode_group.command(name="about", aliases=("ab", "info"), brief="Learn about Advent of Code")
-    @whitelist_override(channels=AOC_WHITELIST)
+    @in_whitelist(channels=AOC_WHITELIST, redirect=AOC_REDIRECT)
     async def about_aoc(self, ctx: commands.Context) -> None:
         """Respond with an explanation of all things Advent of Code."""
         await ctx.send(embed=self.cached_about_aoc)
 
     @aoc_slash_group.command(name="join", description="Get the join code for our community Advent of Code leaderboard")
-    @whitelist_override(channels=AOC_WHITELIST)
+    @in_whitelist(channels=AOC_WHITELIST, redirect=AOC_REDIRECT)
     @app_commands.guild_only()
     async def join_leaderboard(self, interaction: discord.Interaction) -> None:
         """Send the user an ephemeral message with the information for joining the Python Discord leaderboard."""
@@ -229,7 +231,7 @@ async def join_leaderboard(self, interaction: discord.Interaction) -> None:
         aliases=("connect",),
         brief="Tie your Discord account with your Advent of Code name."
     )
-    @whitelist_override(channels=AOC_WHITELIST)
+    @in_whitelist(channels=AOC_WHITELIST, redirect=AOC_REDIRECT)
     async def aoc_link_account(self, ctx: commands.Context, *, aoc_name: str | None = None) -> None:
         """
         Link your Discord Account to your Advent of Code name.
@@ -282,7 +284,7 @@ async def aoc_link_account(self, ctx: commands.Context, *, aoc_name: str | None
         aliases=("disconnect",),
         brief="Untie your Discord account from your Advent of Code name."
     )
-    @whitelist_override(channels=AOC_WHITELIST)
+    @in_whitelist(channels=AOC_WHITELIST, redirect=AOC_REDIRECT)
     async def aoc_unlink_account(self, ctx: commands.Context) -> None:
         """
         Unlink your Discord ID with your Advent of Code leaderboard name.
@@ -303,7 +305,7 @@ async def aoc_unlink_account(self, ctx: commands.Context) -> None:
         aliases=("daynstar", "daystar"),
         brief="Get a view that lets you filter the leaderboard by day and star",
     )
-    @whitelist_override(channels=AOC_WHITELIST_RESTRICTED)
+    @in_whitelist(channels=AOC_WHITELIST_RESTRICTED, redirect=AOC_REDIRECT)
     async def aoc_day_and_star_leaderboard(
             self,
             ctx: commands.Context,
@@ -341,7 +343,7 @@ async def aoc_day_and_star_leaderboard(
         aliases=("board", "lb"),
         brief="Get a snapshot of the PyDis private AoC leaderboard",
     )
-    @whitelist_override(channels=AOC_WHITELIST_RESTRICTED)
+    @in_whitelist(channels=AOC_WHITELIST_RESTRICTED, redirect=AOC_REDIRECT)
     async def aoc_leaderboard(self, ctx: commands.Context, *, aoc_name: str | None = None) -> None:
         """
         Get the current top scorers of the Python Discord Leaderboard.
@@ -375,7 +377,7 @@ async def aoc_leaderboard(self, ctx: commands.Context, *, aoc_name: str | None =
         table = (
             "```\n"
             f"{leaderboard['placement_leaderboard'] if aoc_name else leaderboard['top_leaderboard']}"
-             "\n```"
+            "\n```"
         )
         info_embed = _helpers.get_summary_embed(leaderboard)
 
@@ -388,7 +390,7 @@ async def aoc_leaderboard(self, ctx: commands.Context, *, aoc_name: str | None =
         aliases=("globalboard", "gb"),
         brief="Get a link to the global leaderboard",
     )
-    @whitelist_override(channels=AOC_WHITELIST_RESTRICTED)
+    @in_whitelist(channels=AOC_WHITELIST_RESTRICTED, redirect=AOC_REDIRECT)
     async def aoc_global_leaderboard(self, ctx: commands.Context) -> None:
         """Get a link to the global Advent of Code leaderboard."""
         url = self.global_leaderboard_url
@@ -404,7 +406,7 @@ async def aoc_global_leaderboard(self, ctx: commands.Context) -> None:
         aliases=("dailystats", "ds"),
         brief="Get daily statistics for the Python Discord leaderboard"
     )
-    @whitelist_override(channels=AOC_WHITELIST_RESTRICTED)
+    @in_whitelist(channels=AOC_WHITELIST_RESTRICTED, redirect=AOC_REDIRECT)
     async def private_leaderboard_daily_stats(self, ctx: commands.Context) -> None:
         """Send an embed with daily completion statistics for the Python Discord leaderboard."""
         try:
@@ -429,7 +431,7 @@ async def private_leaderboard_daily_stats(self, ctx: commands.Context) -> None:
             info_embed = _helpers.get_summary_embed(leaderboard)
             await ctx.send(f"```\n{table}\n```", embed=info_embed)
 
-    @with_role(Roles.admins)
+    @with_role(Roles.admins, fail_silently=True)
     @adventofcode_group.command(
         name="refresh",
         aliases=("fetch",),
@@ -473,9 +475,3 @@ def _build_about_embed(self) -> discord.Embed:
 
         about_embed.set_footer(text="Last Updated")
         return about_embed
-
-    async def cog_command_error(self, ctx: commands.Context, error: Exception) -> None:
-        """Custom error handler if an advent of code command was posted in the wrong channel."""
-        if isinstance(error, InChannelCheckFailure):
-            await ctx.send(f":x: Please use <#{Channels.advent_of_code_commands}> for aoc commands instead.")
-            error.handled = True

bot/exts/core/__init__.py

@@ -0,0 +1,148 @@
+from discord import Colour, Embed
+from discord.ext.commands import (
+    Cog,
+    CommandError,
+    Context,
+    errors,
+)
+
+from bot.bot import SirRobin
+from bot.log import get_logger
+from bot.utils.exceptions import (
+    InMonthCheckFailure,
+    InWhitelistCheckFailure,
+    SilentCheckFailure,
+)
+
+log = get_logger(__name__)
+
+
+class ErrorHandler(Cog):
+    """Handles errors emitted from commands."""
+
+    def __init__(self, bot: SirRobin):
+        self.bot = bot
+
+    @staticmethod
+    def _get_error_embed(title: str, body: str) -> Embed:
+        """Return a embed with our error colour assigned."""
+        return Embed(
+            title=title,
+            colour=Colour.brand_red(),
+            description=body
+        )
+
+    @Cog.listener()
+    async def on_command_error(self, ctx: Context, error: CommandError) -> None:
+        """
+        Generic command error handling from other cogs.
+
+        Using the error type, handle the error appropriately.
+            if there is no handling for the error type raised,
+            a message will be sent to the user & it will be logged.
+
+        In the future, I would expect this to be used as a place
+            to push errors to a sentry instance.
+        """
+        log.trace(f"Handling a raised error {error} from {ctx.command}")
+
+        if isinstance(error, errors.UserInputError):
+            await self.handle_user_input_error(ctx, error)
+            return
+
+        if isinstance(error, errors.CheckFailure):
+            await self.handle_check_failure(ctx, error)
+            return
+
+        if isinstance(error, errors.CommandNotFound):
+            embed = self._get_error_embed("Command not found", str(error))
+        else:
+            # If we haven't handled it by this point, it is considered an unexpected/handled error.
+            log.exception(f"Error executing command invoked by {ctx.message.author}: {ctx.message.content}")
+            embed = self._get_error_embed(
+                "Unexpected error",
+                "Sorry, an unexpected error occurred. Please let us know!\n\n"
+                f"```{error.__class__.__name__}: {error}```"
+            )
+        await ctx.send(embed=embed)
+
+    async def handle_user_input_error(self, ctx: Context, e: errors.UserInputError) -> None:
+        """
+        Send an error message in `ctx` for UserInputError, sometimes invoking the help command too.
+
+        * MissingRequiredArgument: send an error message with arg name and the help command
+        * TooManyArguments: send an error message and the help command
+        * BadArgument: send an error message and the help command
+        * BadUnionArgument: send an error message including the error produced by the last converter
+        * ArgumentParsingError: send an error message
+        * Other: send an error message and the help command
+        """
+        if isinstance(e, errors.MissingRequiredArgument):
+            embed = self._get_error_embed("Missing required argument", e.param.name)
+        elif isinstance(e, errors.TooManyArguments):
+            embed = self._get_error_embed("Too many arguments", str(e))
+        elif isinstance(e, errors.BadArgument):
+            embed = self._get_error_embed("Bad argument", str(e))
+        elif isinstance(e, errors.BadUnionArgument):
+            embed = self._get_error_embed("Bad argument", f"{e}\n{e.errors[-1]}")
+        elif isinstance(e, errors.ArgumentParsingError):
+            embed = self._get_error_embed("Argument parsing error", str(e))
+        else:
+            embed = self._get_error_embed(
+                "Input error",
+                "Something about your input seems off. Check the arguments and try again."
+            )
+
+        await ctx.send(embed=embed)
+
+    async def handle_check_failure(self, ctx: Context, e: errors.CheckFailure) -> None:
+        """
+        Send an error message in `ctx` for certain types of CheckFailure.
+
+        The following types are handled:
+
+        * BotMissingPermissions
+        * BotMissingRole
+        * BotMissingAnyRole
+        * MissingAnyRole
+        * InMonthCheckFailure
+        * SilentCheckFailure
+        * InWhitelistCheckFailure
+        * NoPrivateMessage
+        """
+        bot_missing_errors = (
+            errors.BotMissingPermissions,
+            errors.BotMissingRole,
+            errors.BotMissingAnyRole
+        )
+
+        if isinstance(e, SilentCheckFailure):
+            # Silently fail, SirRobin should not respond
+            log.info(
+                f"{ctx.author} ({ctx.author.id}) tried to run {ctx.command} "
+                f"but hit a silent check failure {e.__class__.__name__}",
+            )
+            return
+
+        if isinstance(e, bot_missing_errors):
+            embed = self._get_error_embed("Permission error", "I don't have the permission I need to do that!")
+        elif isinstance(e, errors.MissingAnyRole):
+            embed = self._get_error_embed("Permission error", "You are not allowed to use this command!")
+        elif isinstance(e, InMonthCheckFailure):
+            embed = self._get_error_embed("Command not available", str(e))
+        elif isinstance(e, InWhitelistCheckFailure):
+            embed = self._get_error_embed("Wrong Channel", str(e))
+        elif isinstance(e, errors.NoPrivateMessage):
+            embed = self._get_error_embed("Wrong channel", "This command can not be ran in DMs!")
+        else:
+            embed = self._get_error_embed(
+                "Unexpected check failure",
+                "Sorry, an unexpected check error occurred. Please let us know!\n\n"
+                f"```{e.__class__.__name__}: {e}```"
+            )
+        await ctx.send(embed=embed)
+
+
+async def setup(bot: SirRobin) -> None:
+    """Load the ErrorHandler cog."""
+    await bot.add_cog(ErrorHandler(bot))