Merge branch 'main' into main

Author: brandons209

appeals/bugreport.py

@@ -40,7 +40,7 @@ async def column_bug():
     # Insert a row
     guild = SomeTable(num1=guild_id, num2=guild_id, num3=guild_id)
     await guild.save()
-    res = await SomeTable.select().first()
+    res: dict = await SomeTable.select().first()
     print("PICCOLO")
     print("num1", res["num1"], type(res["num1"]))
     print("num2", res["num2"], type(res["num2"]))
@@ -68,7 +68,7 @@ async def update_bug():
     number = 123
     guild = SomeTable(num1=number, num2=number, num3=number)
     await guild.save()
-    res = await SomeTable.select().first()
+    res: dict = await SomeTable.select().first()
     print("BEFORE")
     print("num1", res["num1"])
     print("num2", res["num2"], type(res["num2"]))

appeals/commands/admin.py

@@ -15,24 +15,6 @@
 log = logging.getLogger("red.vrt.appeals.commands.admin")
 
 
-class MessageParser:
-    def __init__(self, argument):
-        if "-" not in argument:
-            raise commands.BadArgument("Invalid format, must be `channelID-messageID`")
-        try:
-            cid, mid = [i.strip() for i in argument.split("-")]
-        except ValueError:
-            raise commands.BadArgument("Invalid format, must be `channelID-messageID`")
-        try:
-            self.channel_id = int(cid)
-        except ValueError:
-            raise commands.BadArgument("Channel ID must be an integer")
-        try:
-            self.message_id = int(mid)
-        except ValueError:
-            raise commands.BadArgument("Message ID must be an integer")
-
-
 class Admin(MixinMeta):
     async def no_appealguild(self, ctx: commands.Context):
         txt = (
@@ -161,7 +143,7 @@ async def view_appeal_settings(self, ctx: commands.Context):
 
         def cname(cid: int):
             if cid:
-                channel = self.bot.get_channel(cid)
+                channel: discord.TextChannel = self.bot.get_channel(cid)
                 if channel:
                     return channel.mention
                 else:
@@ -185,7 +167,9 @@ def cname(cid: int):
             f"**Appeal Message**: {appeal_msg}\n"
             f"**Alert Channel**: {cname(appealguild.alert_channel)}\n"
             f"**Appeal Limit**: {appealguild.appeal_limit}\n"
-            f"**Alert Roles**: {', '.join([r.mention for r in roles]) if roles else 'None set'}\n"
+            f"**Discussion Threads**: {'Enabled' if appealguild.discussion_threads else 'Disabled'}\n"
+            f"**Vote Emojis**: {'Enabled' if appealguild.vote_emojis else 'Disabled'}\n"
+            f"**Alert Roles**: {', '.join([r for r in roles]) if roles else 'None set'}\n"
             f"**Questions**: {await AppealQuestion.count().where(AppealQuestion.guild == ctx.guild.id)}"
         )
         embed = discord.Embed(
@@ -254,13 +238,13 @@ async def approve_appeal(self, ctx: commands.Context, submission_id: int, *, rea
         if not member:
             member = await self.bot.get_or_fetch_user(submission.user_id)
         # Send the submission to the approved channel and then delete from the pending channel
-        approved_channel = ctx.guild.get_channel(appealguild.approved_channel)
+        approved_channel: discord.TextChannel = ctx.guild.get_channel(appealguild.approved_channel)
         if approved_channel:
             new_message = await approved_channel.send(embed=submission.embed(member))
             await AppealSubmission.update({AppealSubmission.message_id: new_message.id}).where(
                 (AppealSubmission.id == submission_id) & (AppealSubmission.guild == ctx.guild.id)
             )
-        pending_channel = ctx.guild.get_channel(appealguild.pending_channel)
+        pending_channel: discord.TextChannel = ctx.guild.get_channel(appealguild.pending_channel)
         if pending_channel:
             if not pending_channel.permissions_for(ctx.guild.me).manage_messages:
                 await ctx.send(f"I do not have permissions to delete messages from {pending_channel.mention}")
@@ -269,6 +253,8 @@ async def approve_appeal(self, ctx: commands.Context, submission_id: int, *, rea
                     message = await pending_channel.fetch_message(submission.message_id)
                     if message.thread:
                         await message.thread.delete()
+                    elif thread := ctx.guild.get_thread(submission.discussion_thread):
+                        await thread.delete()
                     await message.delete()
                 except discord.NotFound:
                     await ctx.send(f"Submission message not found in {pending_channel.mention}")
@@ -349,16 +335,18 @@ async def deny_appeal(self, ctx: commands.Context, submission_id: int, *, reason
         submission.status = "denied"
         submission.reason = reason or ""
         await ctx.send(f"Successfully denied submission ID: {submission_id}")
-        member = ctx.guild.get_member(submission.user_id) or self.bot.get_user(submission.user_id)
+        member = ctx.guild.get_member(submission.user_id)
+        if not member:
+            member = await self.bot.get_or_fetch_user(submission.user_id)
         # Send the submission to the denied channel and then delete from the pending channel
-        denied_channel = ctx.guild.get_channel(appealguild.denied_channel)
+        denied_channel: discord.TextChannel = ctx.guild.get_channel(appealguild.denied_channel)
         if denied_channel:
             new_embed = submission.embed(member)
             new_message = await denied_channel.send(embed=new_embed)
             await AppealSubmission.update({AppealSubmission.message_id: new_message.id}).where(
                 (AppealSubmission.id == submission_id) & (AppealSubmission.guild == ctx.guild.id)
             )
-        pending_channel = ctx.guild.get_channel(appealguild.pending_channel)
+        pending_channel: discord.TextChannel = ctx.guild.get_channel(appealguild.pending_channel)
         if pending_channel:
             if not pending_channel.permissions_for(ctx.guild.me).manage_messages:
                 await ctx.send(f"I do not have permissions to delete messages from {pending_channel.mention}")
@@ -367,6 +355,8 @@ async def deny_appeal(self, ctx: commands.Context, submission_id: int, *, reason
                     message = await pending_channel.fetch_message(submission.message_id)
                     if message.thread:
                         await message.thread.delete()
+                    elif thread := ctx.guild.get_thread(submission.discussion_thread):
+                        await thread.delete()
                     await message.delete()
                 except discord.NotFound:
                     await ctx.send(f"Submission message not found in {pending_channel.mention}")
@@ -396,7 +386,7 @@ async def delete_appeal(self, ctx: commands.Context, submission_id: int):
         )
         if not submission:
             return await ctx.send("No submission found with that ID.")
-        channel = ctx.guild.get_channel(getattr(appealguild, f"{submission.status}_channel"))
+        channel: discord.TextChannel = ctx.guild.get_channel(getattr(appealguild, f"{submission.status}_channel"))
         if channel:
             if not channel.permissions_for(ctx.guild.me).manage_messages:
                 await ctx.send(f"I do not have permissions to delete messages from {channel.mention}")
@@ -463,6 +453,16 @@ async def set_channels(
         if not appealguild:
             return await self.no_appealguild(ctx)
 
+        permissions = {
+            "View Channel": channel.permissions_for(ctx.guild.me).view_channel,
+            "Send Messages": channel.permissions_for(ctx.guild.me).send_messages,
+            "Embed Links": channel.permissions_for(ctx.guild.me).embed_links,
+            "Create Threads": channel.permissions_for(ctx.guild.me).create_public_threads,
+        }
+        for perm, has_perm in permissions.items():
+            if not has_perm:
+                return await ctx.send(f"I don't have the `{perm}` permission in {channel.mention}!")
+
         if channel_type == "pending":
             if channel.id == appealguild.pending_channel:
                 return await ctx.send("That channel is already set as the pending appeals channel.")
@@ -508,19 +508,21 @@ async def create_appeal_message(self, ctx: commands.Context, channel: discord.Te
 
     @ensure_db_connection()
     @appealset.command(name="appealmessage")
-    async def set_appeal_message(self, ctx: commands.Context, message: MessageParser):
+    async def set_appeal_message(self, ctx: commands.Context, message: discord.Message):
         """
         Set the message where users will appeal from
         Message format: `channelID-messageID`
         """
         appealguild = await AppealGuild.objects().get(AppealGuild.id == ctx.guild.id)
         if not appealguild:
             return await self.no_appealguild(ctx)
-        channel = ctx.guild.get_channel(message.channel_id)
+        channel = ctx.guild.get_channel(message.channel.id)
         if not channel:
             return await ctx.send("Invalid channel ID provided.")
+        if not isinstance(channel, discord.TextChannel):
+            return await ctx.send("The provided channel ID is not a text channel.")
         try:
-            msg = await channel.fetch_message(message.message_id)
+            msg = await channel.fetch_message(message.channel.id)
         except discord.NotFound:
             return await ctx.send("Invalid message ID provided.")
         except discord.Forbidden:
@@ -546,11 +548,11 @@ async def add_appeal_question(self, ctx: commands.Context, *, question: str):
         count = await AppealQuestion.count().where(AppealQuestion.guild == appealguild)
         if count >= 24:
             return await ctx.send("You can only have up to 24 questions in the appeal form.")
-        question = AppealQuestion(
+        question_obj = AppealQuestion(
             guild=ctx.guild.id,
             question=question,
         )
-        await question.save()
+        await question_obj.save()
         await ctx.send("Successfully added the question to the appeal form.")
         await self.refresh(ctx)
 
@@ -778,15 +780,16 @@ async def set_alert_roles(self, ctx: commands.Context, *, role: discord.Role | i
         These roles will be pinged in the appeal server, NOT the target server.
         """
         rid = role.id if isinstance(role, discord.Role) else role
+        role_name = role.mention if isinstance(role, discord.Role) else f"<@&{rid}>"
         appealguild = await AppealGuild.objects().get(AppealGuild.id == ctx.guild.id)
         if not appealguild:
             return await self.no_appealguild(ctx)
         if rid in appealguild.alert_roles:
             appealguild.alert_roles.remove(rid)
-            await ctx.send(f"Removed {role.name} from the alert roles.")
+            await ctx.send(f"Removed {role_name} from the alert roles.")
         else:
             appealguild.alert_roles.append(rid)
-            await ctx.send(f"Added {role.name} to the alert roles.")
+            await ctx.send(f"Added {role_name} to the alert roles.")
         await AppealGuild.update({AppealGuild.alert_roles: appealguild.alert_roles}).where(
             AppealGuild.id == ctx.guild.id
         )
@@ -804,9 +807,11 @@ async def set_alert_channel(self, ctx: commands.Context, *, channel: discord.Tex
         if not appealguild:
             return await self.no_appealguild(ctx)
         if isinstance(channel, int):
-            channel = self.bot.get_channel(channel)
+            channel: discord.TextChannel = self.bot.get_channel(channel)
             if not channel:
                 return await ctx.send("Invalid channel ID provided.")
+        if not isinstance(channel, discord.TextChannel):
+            return await ctx.send("You must provide a valid text channel.")
         if channel:
             await AppealGuild.update({AppealGuild.alert_channel: channel.id}).where(AppealGuild.id == ctx.guild.id)
             return await ctx.send(f"Successfully set the alert channel to {channel.mention}")
@@ -827,7 +832,7 @@ async def refresh(self, ctx: discord.Guild | commands.Context) -> str | None:
                 await ctx.send(f"Appeal system not ready yet: {reason}")
             return reason
         appealguild = await AppealGuild.objects().get(AppealGuild.id == guild.id)
-        channel = guild.get_channel(appealguild.appeal_channel)
+        channel: discord.TextChannel = guild.get_channel(appealguild.appeal_channel)
         message = await channel.fetch_message(appealguild.appeal_message)
         view = AppealView(custom_id=f"{appealguild.id}")
         await message.edit(view=view)
@@ -915,3 +920,33 @@ async def set_button_emoji(
         )
         await ctx.send("Successfully removed the button emoji", view=view)
         await self.refresh(ctx)
+
+    @ensure_db_connection()
+    @appealset.command(name="discussionthreads")
+    async def toggle_discussion_threads(self, ctx: commands.Context):
+        """Toggle whether appeals will have a discussion thread created for them"""
+        appealguild = await AppealGuild.objects().get(AppealGuild.id == ctx.guild.id)
+        if not appealguild:
+            return await self.no_appealguild(ctx)
+        if appealguild.discussion_threads:
+            appealguild.discussion_threads = False
+            await ctx.send("Successfully disabled discussion threads for appeals.")
+        else:
+            appealguild.discussion_threads = True
+            await ctx.send("Successfully enabled discussion threads for appeals.")
+        await appealguild.save([AppealGuild.discussion_threads])
+
+    @ensure_db_connection()
+    @appealset.command(name="voteemojis")
+    async def toggle_vote_emojis(self, ctx: commands.Context):
+        """Toggle whether appeals will have vote emojis added to them"""
+        appealguild = await AppealGuild.objects().get(AppealGuild.id == ctx.guild.id)
+        if not appealguild:
+            return await self.no_appealguild(ctx)
+        if appealguild.vote_emojis:
+            appealguild.vote_emojis = False
+            await ctx.send("Successfully disabled vote emojis for appeals.")
+        else:
+            appealguild.vote_emojis = True
+            await ctx.send("Successfully enabled vote emojis for appeals.")
+        await appealguild.save([AppealGuild.vote_emojis])

appeals/db/migrations/appeals_2025_06_06t20_23_41_085322.py

@@ -0,0 +1,78 @@
+from piccolo.apps.migrations.auto.migration_manager import MigrationManager
+from piccolo.columns.column_types import BigInt, Boolean
+from piccolo.columns.indexes import IndexMethod
+
+ID = "2025-06-06T20:23:41:085322"
+VERSION = "1.13.0"
+DESCRIPTION = "discussion thread and vote emoji toggles"
+
+
+async def forwards():
+    manager = MigrationManager(
+        migration_id=ID, app_name="appeals", description=DESCRIPTION
+    )
+
+    manager.add_column(
+        table_class_name="AppealGuild",
+        tablename="appeal_guild",
+        column_name="discussion_threads",
+        db_column_name="discussion_threads",
+        column_class_name="Boolean",
+        column_class=Boolean,
+        params={
+            "default": True,
+            "null": False,
+            "primary_key": False,
+            "unique": False,
+            "index": False,
+            "index_method": IndexMethod.btree,
+            "choices": None,
+            "db_column_name": None,
+            "secret": False,
+        },
+        schema=None,
+    )
+
+    manager.add_column(
+        table_class_name="AppealGuild",
+        tablename="appeal_guild",
+        column_name="vote_emojis",
+        db_column_name="vote_emojis",
+        column_class_name="Boolean",
+        column_class=Boolean,
+        params={
+            "default": False,
+            "null": False,
+            "primary_key": False,
+            "unique": False,
+            "index": False,
+            "index_method": IndexMethod.btree,
+            "choices": None,
+            "db_column_name": None,
+            "secret": False,
+        },
+        schema=None,
+    )
+
+    manager.add_column(
+        table_class_name="AppealSubmission",
+        tablename="appeal_submission",
+        column_name="discussion_thread",
+        db_column_name="discussion_thread",
+        column_class_name="BigInt",
+        column_class=BigInt,
+        params={
+            "default": 0,
+            "null": False,
+            "primary_key": False,
+            "unique": False,
+            "index": False,
+            "index_method": IndexMethod.btree,
+            "choices": None,
+            "db_column_name": None,
+            "secret": False,
+        },
+        schema=None,
+    )
+
+    return manager

appeals/db/tables.py

@@ -31,6 +31,9 @@ class AppealGuild(Table):
     alert_roles = Array(BigInt())  # Roles to alert when a new appeal is submitted
     alert_channel = BigInt()  # Channel to alert when a new appeal is submitted
     appeal_limit = Integer(default=1)  # Maximum number of times a user can submit an appeal
+    discussion_threads = Boolean(default=True)  # Whether to create discussion threads for appeals
+    vote_emojis = Boolean(default=False)  # Whether to add basic check and cross emojis to the appeal message
+
     # Appeal button
     button_style = Text(default="primary")  # can be `primary`, `secondary`, `success`, `danger`
     button_label = Text(default="Submit Appeal")
@@ -100,6 +103,9 @@ class AppealSubmission(Table):
     message_id = BigInt()  # Message ID of the submission message
     reason = Text()  # Reason for denial
 
+    # 0.2.0+
+    discussion_thread = BigInt()  # ID of the discussion thread for this question, if applicable
+
     def created(self, type: t.Literal["t", "T", "d", "D", "f", "F", "R"]) -> str:
         return f"<t:{int(self.created_at.timestamp())}:{type}>"
 

appeals/main.py

@@ -25,12 +25,12 @@ class Appeals(Commands, Listeners, commands.Cog, metaclass=CompositeMetaClass):
     """Straightforward ban appeal system for Discord servers."""
 
     __author__ = "[vertyco](https://github.com/vertyco/vrt-cogs)"
-    __version__ = "0.1.2"
+    __version__ = "0.2.1"
 
     def __init__(self, bot: Red):
         super().__init__()
         self.bot: Red = bot
-        self.db: SQLiteEngine = None
+        self.db: SQLiteEngine | None = None
         self.db_utils: DBUtils = DBUtils()
 
     def format_help_for_context(self, ctx: commands.Context):