Create an admin task when votes are 2 weeks old

bot/constants.py

@@ -683,6 +683,14 @@ class VideoPermission(metaclass=YAMLGetter):
     default_permission_duration: int
 
 
+class GithubAdminRepo(metaclass=YAMLGetter):
+    section = "github_admin_repo"
+
+    owner: str
+    name: str
+    token: str
+
+
 class ThreadArchiveTimes(Enum):
     HOUR = 60
     DAY = 1440

bot/exts/recruitment/talentpool/_cog.py

@@ -1,17 +1,21 @@
 import asyncio
 import textwrap
 from io import StringIO
-from typing import Optional, Union
+from typing import Optional, Tuple, Union
 
+import arrow
 import discord
 from async_rediscache import RedisCache
 from discord import Color, Embed, Member, PartialMessage, RawReactionActionEvent, User
 from discord.ext import commands, tasks
 from discord.ext.commands import BadArgument, Cog, Context, group, has_any_role
+from discord.utils import snowflake_time
 from pydis_core.site_api import ResponseCodeError
 
 from bot.bot import Bot
-from bot.constants import Bot as BotConfig, Channels, Emojis, Guild, MODERATION_ROLES, Roles, STAFF_ROLES
+from bot.constants import (
+    Bot as BotConfig, Channels, Emojis, GithubAdminRepo, Guild, MODERATION_ROLES, Roles, STAFF_ROLES
+)
 from bot.converters import MemberOrUser, UnambiguousMemberOrUser
 from bot.exts.recruitment.talentpool._review import Reviewer
 from bot.log import get_logger
@@ -23,7 +27,9 @@
 from ._api import Nomination, NominationAPI
 
 AUTOREVIEW_ENABLED_KEY = "autoreview_enabled"
+FLAG_EMOJI = "🎫"
 REASON_MAX_CHARS = 1000
+OLD_NOMINATIONS_THRESHOLD_IN_DAYS = 14
 
 log = get_logger(__name__)
 
@@ -44,6 +50,11 @@ def __init__(self, bot: Bot) -> None:
 
     async def cog_load(self) -> None:
         """Start autoreview loop if enabled."""
+        if not GithubAdminRepo.token:
+            log.warning(f"No token for the {GithubAdminRepo.name} repository was provided, skipping issue creation.")
+        else:
+            self.track_forgotten_nominations.start()
+
         if await self.autoreview_enabled():
             self.autoreview_loop.start()
 
@@ -112,6 +123,92 @@ async def autoreview_status(self, ctx: Context) -> None:
         else:
             await ctx.send("Autoreview is currently disabled.")
 
+    @tasks.loop(hours=72)
+    async def track_forgotten_nominations(self) -> None:
+        """Track active nominations who are more than 2 weeks old."""
+        old_nominations = await self._get_forgotten_nominations()
+        untracked_nominations = await self._find_untracked_nominations(old_nominations)
+        for nomination, thread in untracked_nominations:
+            issue_created = await self._track_vote_in_github(nomination, thread.jump_url)
+            if issue_created:
+                await thread.starter_message.add_reaction(FLAG_EMOJI)
+
+    async def _get_forgotten_nominations(self) -> list[Nomination]:
+        """Get active nominations that are more than 2 weeks old."""
+        now = arrow.utcnow()
+        nominations = [
+            nomination
+            for nomination in await self.api.get_nominations(active=True)
+            if (
+                nomination.thread_id and
+                (now - snowflake_time(nomination.thread_id)).days >= OLD_NOMINATIONS_THRESHOLD_IN_DAYS
+            )
+        ]
+        return nominations
+
+    async def _find_untracked_nominations(
+            self,
+            nominations: list[Nomination]
+    ) -> list[Tuple[Nomination, discord.Thread]]:
+        """
+        Returns a list of tuples representing a nomination and its vote message.
+
+        All active nominations are iterated over to identify whether they're tracked or not
+        by checking whether the nomination message has the "🎫" emoji or not
+        """
+        untracked_nominations = []
+
+        for nomination in nominations:
+            # We avoid the scenario of this task run & nomination created at the same time
+            if not nomination.thread_id:
+                continue
+
+            try:
+                thread = await get_or_fetch_channel(nomination.thread_id)
+            except discord.NotFound:
+                log.debug(f"Couldn't find thread {nomination.thread_id}")
+                continue
+
+            starter_message = thread.starter_message
+            if not starter_message:
+                # Starter message will be null if it's not cached
+                try:
+                    starter_message = await self.bot.get_channel(Channels.nomination_voting).fetch_message(thread.id)
+                except discord.NotFound:
+                    log.debug(f"Couldn't find message {thread.id} in channel: {Channels.nomination_voting}")
+                    continue
+
+            if FLAG_EMOJI in [reaction.emoji for reaction in starter_message.reactions]:
+                # Nomination has been already tracked in GitHub
+                continue
+
+            untracked_nominations.append((nomination, thread))
+        return untracked_nominations
+
+    async def _track_vote_in_github(self, nomination: Nomination, vote_jump_url: str | None = None) -> bool:
+        """
+        Adds an issue in GitHub to track dormant vote.
+
+        Returns True when the issue has been created, False otherwise.
+        """
+        url = f"https://api.github.com/repos/{GithubAdminRepo.owner}/{GithubAdminRepo.name}/issues"
+        headers = {
+            "Accept": "application/vnd.github.v3+json",
+            "Authorization": f"Bearer {GithubAdminRepo.token}"
+        }
+        member = await get_or_fetch_member(self.bot.get_guild(Guild.id), nomination.user_id)
+        if not member:
+            log.debug(f"Couldn't find member: {nomination.user_id}")
+            return False
+
+        data = {"title": f"Nomination review needed. Id: {nomination.id}. User: {member.name}"}
+        if vote_jump_url:
+            data["body"] = f"Jump to the [vote message]({vote_jump_url})"
+
+        async with self.bot.http_session.post(url=url, raise_for_status=True, headers=headers, json=data) as response:
+            log.debug(f"Creating a review reminder issue for user {member.name}")
+            return response.status == 201
+
     @tasks.loop(hours=1)
     async def autoreview_loop(self) -> None:
         """Send request to `reviewer` to send a nomination if ready."""

config-default.yml

@@ -545,7 +545,7 @@ voice_gate:
 
 
 branding:
-    cycle_frequency: 3  # How many days bot wait before refreshing server icon
+    cycle_frequency: 3  # How many days the bot waits before refreshing server icon
 
 
 config:
@@ -554,3 +554,9 @@ config:
 
 video_permission:
     default_permission_duration: 5  # Default duration for stream command in minutes
+
+
+github_admin_repo:
+    owner: 'python-discord'
+    name: 'admin-tasks'
+    token: !ENV ["ADMIN_GITHUB_REPO_TOKEN", ""]