Initial work on roles, but it will be complicated. Creating a checkpoint and moving on the smaller changes

Author: Paul Philion

Makefile

@@ -28,7 +28,7 @@ htmlcov:
 
 clean:
 	rm -rf __pycache__
-	rm -rf $(VENV)
+	rm -rf .venv/
 	rm -rf htmlcov
 	rm -f discord.log
 	rm -f dpytest_*.dat

netbot/cog_scn.py

@@ -251,6 +251,7 @@ async def sync(self, ctx:discord.ApplicationContext):
     async def reindex(self, ctx:discord.ApplicationContext):
         """reindex the all cached information"""
         self.redmine.reindex()
+        #self.bot.reindex() FIXME, once roles are working
         await ctx.respond("Rebuilt redmine indices.")
 
 

netbot/netbot.py

@@ -8,9 +8,10 @@
 import asyncio
 import discord
 from dotenv import load_dotenv
+from discord import Role
 from discord.ext import commands, tasks
 
-from redmine.model import TicketNote, Ticket, NamedId, Team
+from redmine.model import TicketNote, Ticket, NamedId, Team, TeamSet
 from redmine import synctime
 from redmine.redmine import Client
 
@@ -69,11 +70,15 @@ def __init__(self, client: Client):
         log.info(f'initializing {self}')
         intents = discord.Intents.default()
         intents.message_content = True
+        intents.members = True # Needed to access member roles
 
         self.run_sync = True # ticket sync on by default
         self.lock = asyncio.Lock()
         self.ticket_locks = {}
 
+        self.roles: dict[str,Role] = {}
+        self.teams = TeamSet()
+
         self.formatter = DiscordFormatter(client.url)
 
         self.redmine = client
@@ -96,10 +101,38 @@ def run_bot(self):
         log.info(f"starting {self}")
         super().run(os.getenv('DISCORD_TOKEN'))
 
+
+    def cache_roles(self):
+        # Noting: "guild" maps to discord server, and the API is designed to run on many "Discord servers" concurrently
+        for guild in self.guilds:
+            for member in guild.members:
+                for role in member.roles:
+                    user = self.redmine.user_mgr.find_discord_user(member.name)
+                    #log.debug(f"<<< {role.name} {user.name}")
+                    if user:
+                        self.teams.add_user(role.name, user.name, user.id)
+                    else:
+                        log.warning(f"Unknown user: {member.name} for team: {role.name}")
+
+        log.debug(f"Loaded teams: {self.teams}")
+
+
+    def get_all_teams(self, include_users: bool = True) -> dict[str, Team]:
+        return self.teams
+
+
+    def reindex(self):
+        log.debug("NetBot.reindex")
+        self.cache_roles()
+
+
     async def on_ready(self):
         #log.info(f"Logged in as {self.user} (ID: {self.user.id})")
         #log.debug(f"bot: {self}, guilds: {self.guilds}")
 
+        # reindex: cache roles, etc.
+        self.reindex()
+
         # start the tasks running
         self.sync_all_threads.start()
         self.run_daily_tasks.start()
@@ -244,11 +277,8 @@ def get_channel_by_name(self, channel_name: str) -> discord.TextChannel:
 
 
     def get_role_by_name(self, role_name: str) -> discord.Role:
-        # Noting: "guild" maps to discord server, and the API is designed to run on many "Discord servers" concurrently
-        for guild in self.guilds:
-            for role in guild.roles:
-                if role_name == role.name:
-                    return role
+        # Load from cache
+        return self.roles.get(role_name, None)
 
 
     async def on_application_command_error(self, context: discord.ApplicationContext,

redmine/model.py

@@ -170,6 +170,44 @@ def __post_init__(self):
     def __str__(self) -> str:
         return self.name
 
+    def add_user(self, named:NamedId):
+        if not self.users:
+            self.users = []
+        self.users.append(named)
+
+
+class TeamSet:
+    _teams: dict[str,Team] = {}
+
+    def __str__(self) -> str:
+        return str(self._teams)
+
+    def get(self, name: str) -> Team:
+        self._teams.get(name, None)
+
+
+    def in_team(self, username:str, teamname:str) -> bool:
+        if username is None or teamname is None:
+            return False
+
+        team = self.get(teamname)
+        if team:
+            for team_user in team.users:
+                if team_user.name == username:
+                    return True
+
+        return False
+
+
+    def add_user(self, teamname:str, username:str, userid:int) -> None:
+        team = self.get(teamname)
+        if not team:
+            team = Team(id=-1, name=teamname)
+            team.users = []
+            self._teams[teamname] = team
+        # TODO check if user already in team before adding: set behavior.
+        team.add_user(NamedId(userid, username))
+
 
 DISCORD_ID_FIELD = "Discord ID"