feat: add enable_mark_as_solved functionality and database support

Author: mystique09

migrations/add_enable_mark_as_solved.sql

@@ -0,0 +1,3 @@
+-- depends: 18_post_assist
+ALTER TABLE pph_post_assist_config
+ADD COLUMN IF NOT EXISTS enable_mark_as_solved BOOLEAN DEFAULT FALSE;

src/cogs/forum/auto_tagging.py

@@ -36,15 +36,13 @@
 
 AUTHOR_PLACEHOLDER = "[[@author]]"
 
+
 def get_tag_options(db: DevHelpTagDB, forum: ForumChannel) -> View | None:
     """Gets all tag options for the given forum."""
 
     async def select_callback(interaction: Interaction):
         await db.update("tag_id", int(tag_selection.values[0]))
-        await interaction.response.edit_message(
-            content=f"Success...",
-            view=None
-        )
+        await interaction.response.edit_message(content=f"Success...", view=None)
         view.stop()
 
     view = View()
@@ -56,12 +54,14 @@ async def select_callback(interaction: Interaction):
 
     for a_tag in forum.available_tags:
         tag_selection.add_option(
-            label=f"{a_tag.emoji}{a_tag.name}" if a_tag.emoji else a_tag.name, value=a_tag.id
+            label=f"{a_tag.emoji}{a_tag.name}" if a_tag.emoji else a_tag.name,
+            value=a_tag.id,
         )
 
     view.add_item(tag_selection)
     return view
 
+
 def _getter(guild: Guild, entry: dict) -> Member | Role:
     """Gets the object type and returns it."""
 
@@ -111,7 +111,7 @@ async def load(self):
                     staff_roles,
                     self.logger,
                 ),
-                message_id=view["message_id"]
+                message_id=view["message_id"],
             )
 
     async def cog_load(self):
@@ -149,28 +149,31 @@ async def try_send() -> Message:
                             thread.owner_id,
                             self.dev_help_views_db,
                             self.dev_help_tag_db,
-                            self.forum,
+                            thread.parent,
                             staff_roles,
                             self.logger,
-                        )
+                        ),
                     )
                 except Forbidden:
                     pass
 
-        config = await self.config.get_config("dev_help")
+        config_id, is_enabled = await self.db.is_mark_as_solved_enabled_for_forum(
+            thread.parent_id
+        )
 
-        if not config["config_status"]:
+        if not is_enabled:
             return
 
-        settings = await self.dev_help_tag_db.get()
-
-        if not settings:
+        global_config = await self.config.get_config("auto_tagging")
+        if not global_config["config_status"]:
             return
 
-        if not self.forum:
+        entry = await self.db.config_by_forum(thread.parent.id)
+        if not entry:
             return
 
-        if thread.parent_id != self.forum.id:
+        settings = await self.dev_help_tag_db.get()
+        if not settings:
             return
 
         bot_message = await try_send()
@@ -179,7 +182,9 @@ async def try_send() -> Message:
             return
 
         await bot_message.pin()
-        await self.dev_help_views_db.add_view(thread.id, bot_message.id, thread.owner.id)
+        await self.dev_help_views_db.add_view(
+            thread.id, bot_message.id, thread.owner.id
+        )
 
     async def _notify_subscribers(self, thread: Thread):
         config = await self.config.get_config("auto_tagging")
@@ -279,15 +284,19 @@ async def create_new(self, interaction: Interaction):
                 entity_tag_message=tag_message,
                 reply=reply,
                 enable_accept_solutions=enable_accept_solutions,
+                enable_mark_as_solved=view.state.enable_mark_as_solved,
             )
 
             if view.state.enable_mark_as_solved:
-                forum = await self.bot.fetch_channel(view.state.forum)
-                tag_view = get_tag_options(self.dev_help_tag_db, forum)
-                await interaction.followup.send(view=tag_view, ephemeral=True)
-                await tag_view.wait()
-
-                await interaction.followup.send("Mark as solved button configured.", ephemeral=True)
+                forum_channel = await self.bot.fetch_channel(view.state.forum)
+                tag_view = get_tag_options(self.dev_help_tag_db, forum_channel)
+                if tag_view:
+                    await interaction.followup.send(view=tag_view, ephemeral=True)
+                    await tag_view.wait()
+
+                await interaction.followup.send(
+                    "Mark as solved button configured.", ephemeral=True
+                )
 
             await interaction.followup.send("Success!", ephemeral=True)
             return
@@ -364,6 +373,13 @@ async def edit(self, interaction: Interaction, config_id: int):
         tags = await self.db.get_tags(config_id)
         existing_tags: list[Role] | list[Member] = []
 
+        mark_as_solved_config = await self.db.get_mark_as_solved_config(config_id)
+        current_mark_as_solved = (
+            mark_as_solved_config["enable_mark_as_solved"]
+            if mark_as_solved_config
+            else False
+        )
+
         for tag in tags:
             tag_id = tag["entity_id"]
             if tag["entity_type"] == "role":
@@ -376,6 +392,7 @@ async def edit(self, interaction: Interaction, config_id: int):
             tag_message=tag_message,
             custom_msg=custom_message,
             existing_tags=existing_tags,
+            enable_mark_as_solved=current_mark_as_solved,
         )
 
         modal = PostAssistMessage(state)
@@ -400,7 +417,18 @@ async def edit(self, interaction: Interaction, config_id: int):
                 entities=tags,
                 entity_tag_message=tag_message,
                 reply=reply,
+                enable_mark_as_solved=modal.state.enable_mark_as_solved,
             )
+
+            if modal.state.enable_mark_as_solved:
+                await interaction.followup.send(
+                    "Mark as solved button enabled for this forum.", ephemeral=True
+                )
+            else:
+                await interaction.followup.send(
+                    "Mark as solved button disabled for this forum.", ephemeral=True
+                )
+
             return
 
         await interaction.followup.send("Cancelled.", ephemeral=True)
@@ -416,9 +444,7 @@ async def solved(self, ctx: Context):
 
         description = "This post has been marked as solved."
 
-        embed = Embed(
-            description=description
-        )
+        embed = Embed(description=description)
 
         tag = ctx.channel.parent.get_tag(tag_id)
 

src/data/forum/post_assist.py

@@ -139,13 +139,16 @@ async def add_configuration(
         entity_tag_message: str,
         reply: str,
         enable_accept_solutions: bool,
+        enable_mark_as_solved: bool = False,
     ):
         """Adds a configuration to the database.
 
         :param forum_id: The forum id to add to
         :param entities: The entities to add
         :param entity_tag_message: The tag message
         :param reply: The reply message
+        :param enable_accept_solutions: Whether to enable accept solutions
+        :param enable_mark_as_solved: Whether to enable mark as solved button
         """
 
         async with self._pool.acquire() as conn:
@@ -155,11 +158,13 @@ async def add_configuration(
                 """
                 INSERT INTO pph_post_assist_config(
                     forum_id,
-                    enable_accept_solutions
-                ) VALUES ($1, $2)
+                    enable_accept_solutions,
+                    enable_mark_as_solved
+                ) VALUES ($1, $2, $3)
             """,
                 forum_id,
                 enable_accept_solutions,
+                enable_mark_as_solved,
             )
 
             config = await conn.fetchrow(
@@ -213,13 +218,15 @@ async def update_configuration(
         entities: list[tuple[int, str]],
         entity_tag_message: str,
         reply: str,
+        enable_mark_as_solved: bool | None = None,
     ):
         """Updates a configuration to the database.
 
         :param id: The configuration id to update
         :param entities: The entities to add
         :param entity_tag_message: The tag message
         :param reply: The reply message
+        :param enable_mark_as_solved: Whether to enable mark as solved button
         """
 
         async with self._pool.acquire() as conn:
@@ -230,15 +237,29 @@ async def update_configuration(
             if not config:
                 return
 
-            await conn.execute(
-                """
-                UPDATE pph_post_assist_config SET
-                    forum_id = $1
-                WHERE id = $2;
-            """,
-                forum_id,
-                id,
-            )
+            # Update the main configuration
+            if enable_mark_as_solved is not None:
+                await conn.execute(
+                    """
+                    UPDATE pph_post_assist_config SET
+                        forum_id = $1,
+                        enable_mark_as_solved = $3
+                    WHERE id = $2;
+                """,
+                    forum_id,
+                    id,
+                    enable_mark_as_solved,
+                )
+            else:
+                await conn.execute(
+                    """
+                    UPDATE pph_post_assist_config SET
+                        forum_id = $1
+                    WHERE id = $2;
+                """,
+                    forum_id,
+                    id,
+                )
 
             await conn.execute(
                 """
@@ -255,7 +276,6 @@ async def update_configuration(
                         entity_id,
                         entity_type
                     ) VALUES ($1, $2, $3)
-                
                 """,
                     config["id"],
                     entity_id,
@@ -318,3 +338,68 @@ async def is_mark_as_solution_enabled(self, forum_id: int):
 
             res = (int(res["id"]), bool(res["enable_accept_solutions"]))
             return res
+
+    async def get_mark_as_solved_config(self, config_id: int):
+        """Get the mark as solved configuration for a specific config ID.
+
+        :param config_id: The configuration ID
+        :return: Dictionary with mark as solved settings or None
+        """
+        async with self._pool.acquire() as conn:
+            conn: Pool
+
+            config = await conn.fetchrow(
+                """
+                SELECT enable_mark_as_solved FROM pph_post_assist_config
+                WHERE id = $1;
+                """,
+                config_id,
+            )
+
+        return config if config is not None else None
+
+    async def set_mark_as_solved_config(
+        self, config_id: int, enable_mark_as_solved: bool
+    ):
+        """Update the mark as solved configuration for a config ID.
+
+        :param config_id: The configuration ID
+        :param enable_mark_as_solved: Whether to enable mark as solved button
+        """
+        async with self._pool.acquire() as conn:
+            conn: Pool
+
+            await conn.execute(
+                """
+                UPDATE pph_post_assist_config
+                SET enable_mark_as_solved = $2
+                WHERE id = $1;
+                """,
+                config_id,
+                enable_mark_as_solved,
+            )
+
+    async def is_mark_as_solved_enabled_for_forum(self, forum_id: int):
+        """Check if mark as solved button is enabled for a specific forum.
+
+        :param forum_id: The forum ID
+        :return: Tuple of (config_id, is_enabled)
+        """
+        async with self._pool.acquire() as conn:
+            conn: Pool
+
+            res = await conn.fetchrow(
+                """
+                SELECT id,
+                       COALESCE(enable_mark_as_solved, FALSE)
+                           as enable_mark_as_solved
+                FROM pph_post_assist_config
+                WHERE forum_id = $1;
+                """,
+                forum_id,
+            )
+
+            if not res:
+                return (-1, False)
+
+            return (int(res["id"]), bool(res["enable_mark_as_solved"]))