tmp: Reorder reactions

Author: Gehock

commandListener.py

@@ -10,15 +10,16 @@
 from discord import Member
 from discord.channel import TextChannel
 from discord.emoji import Emoji
-from discord.ext.commands import (BadArgument, Cog, Context,
-                                  MissingRequiredArgument, command)
-from discord.ext.commands.errors import CommandError, CommandInvokeError
+from discord.ext.commands import BadArgument, Cog, Context, command
+from discord.ext.commands.errors import (CommandError, CommandInvokeError,
+                                         MissingRequiredArgument)
 
 import config as cfg
 import messageFunctions as msgFnc
 from converters import (ArgArchivedEvent, ArgDate, ArgDateTime, ArgEvent,
                         ArgMessages, ArgRole, ArgTime, UnquotedStr)
-from errors import MessageNotFound, RoleError, UnexpectedRole
+from errors import (ExtraMessagesFound, MessageNotFound, RoleError,
+                    UnexpectedRole)
 from event import Event
 from eventDatabase import EventDatabase
 from operationbot import OperationBot
@@ -153,7 +154,7 @@ async def _create_event(self, ctx: Context, _date: datetime,
         # Create event and sort events, export
         event: Event = EventDatabase.createEvent(_date, sideop=sideop,
                                                  platoon_size=platoon_size)
-        await msgFnc.createEventMessages(event, self.bot.eventchannel)
+        await msgFnc.get_or_create_messages(event, self.bot.eventchannel)
         if not batch:
             await msgFnc.sortEventMessages(self.bot)
             EventDatabase.toJson()  # Update JSON file
@@ -165,8 +166,8 @@ async def _create_event(self, ctx: Context, _date: datetime,
     async def show(self, ctx: Context, event: ArgEvent):
         message = await msgFnc.getEventMessage(event, self.bot)
         await ctx.send(message.jump_url)
-        await msgFnc.createEventMessages(event, cast(TextChannel, ctx.channel),
-                                         update_id=False)
+        await msgFnc.get_or_create_messages(event, cast(TextChannel,
+                                            ctx.channel), update_id=False)
 
     # Create event command
     @command(aliases=['c'])
@@ -448,7 +449,7 @@ async def _add_role(self, event: Event, rolename: str, batch=False):
                 await self._update_event(event, reorder=False)
             raise e
         if not batch:
-            await self._update_event(event, reorder=False, export=(not batch))
+            await self._update_event(event, reorder=False)
 
     @command(aliases=['ar'])
     async def addrole(self, ctx: Context, event: ArgEvent, *,
@@ -833,7 +834,8 @@ async def archive(self, ctx: Context, event: ArgEvent):
                 await eventMessage.delete()
 
         # Create messages
-        await msgFnc.createEventMessages(event, self.bot.eventarchivechannel)
+        await msgFnc.get_or_create_messages(
+            event, self.bot.eventarchivechannel)
 
         await ctx.send(f"Event {event} archived")
 
@@ -970,7 +972,7 @@ async def _load(self, _: Context, event: Event, data: str,
             raise ValueError("Malformed data")
         if target:
             # Display the loaded event in the command channel
-            await msgFnc.createEventMessages(event, target, update_id=False)
+            await msgFnc.get_or_create_messages(event, target, update_id=False)
         await self._update_event(event)
 
     # @command()
@@ -992,13 +994,16 @@ async def _update_event(self, event: Event, import_db=False,
         try:
             messages = await msgFnc.getEventMessages(event, self.bot,
                                                      exact_number=exact_number)
-        except MessageNotFound:
-            messages = await msgFnc.createEventMessages(event,
-                                                        self.bot.eventchannel)
-
-        await msgFnc.updateMessageEmbeds(messages, event,
-                                         self.bot.eventchannel)
-        await msgFnc.updateReactions(event, bot=self.bot, reorder=reorder)
+        except (MessageNotFound, ExtraMessagesFound) as e:
+            messages = await msgFnc.get_or_create_messages(
+                event, self.bot.eventchannel)
+            if isinstance(e, MessageNotFound):
+                # New messages were created, we need to reorder the messages
+                await msgFnc.sortEventMessages(self.bot)
+        else:
+            await msgFnc.updateMessageEmbeds(messages, event,
+                                             self.bot.eventchannel)
+            await msgFnc.updateReactions(event, bot=self.bot, reorder=reorder)
 
         if export:
             EventDatabase.toJson()

errors.py

@@ -10,6 +10,10 @@ class MessageNotFound(Exception):
     pass
 
 
+class ExtraMessagesFound(Exception):
+    pass
+
+
 class UnexpectedRole(Exception):
     pass
 

event.py

@@ -7,7 +7,7 @@
 import config as cfg
 from additional_role_group import AdditionalRoleGroup
 from errors import RoleError, RoleGroupNotFound, RoleNotFound, RoleTaken
-from role import Role
+from role import ReactionEmoji, Role
 from roleGroup import RoleGroup
 from secret import PLATOON_SIZE
 
@@ -243,47 +243,54 @@ def _create_embed(self, title: str) -> Embed:
                        f"{server_port}"
                        f"{event_description}"
                        f"{mods}")
-        return Embed(title=title, description=description, colour=self.color)
+        embed = Embed(title=title, description=description, colour=self.color)
+        embed.set_footer(text="Event ID: " + str(self.id))
+        return embed
 
-    def createEmbed(self) -> Embed:
+    def create_dummy_embed(self) -> Embed:
         """Return the first embed for the event"""
-        return self.createEmbeds()[0]
+        return self._create_embed(self.title)
 
-    def createEmbeds(self) -> List[Embed]:
-        """Return a list of embeds for the event"""
+    def createEmbeds(self) -> Tuple[List[Embed], List[List[ReactionEmoji]]]:
+        """Return a list of embeds and their corresponding reactions for the
+        event"""
         eventEmbed = self._create_embed(self.title)
+        reactions = []
 
         # Add field to embed for every rolegroup
         for group in self.roleGroups.values():
             if len(group) > 0 and group.name != "Additional":
                 # The Additional group is handled separately
                 eventEmbed.add_field(name=group.name, value=str(group),
                                      inline=group.isInline)
+                reactions += group.get_reactions()
             elif group.name == "Dummy":
                 eventEmbed.add_field(name="\N{ZERO WIDTH SPACE}",
                                      value="\N{ZERO WIDTH SPACE}",
                                      inline=group.isInline)
-        eventEmbed.set_footer(text="Event ID: " + str(self.id))
 
         if len(self.roleGroups["Additional"]) == 0:
             # There are no additional roles, the embed is ready
-            return [eventEmbed]
+            return ([eventEmbed], [reactions])
 
         # Handle additional roles
         if len(self.getReactions()) <= REACTIONS_PER_MESSAGE:
             # All roles fit in a single message
-            group = self.roleGroups["Additional"]
-            eventEmbed.add_field(name=group.name, value=str(group),
-                                 inline=group.isInline)
-            return [eventEmbed]
+            additional = self.roleGroups["Additional"]
+            eventEmbed.add_field(name=additional.name, value=str(additional),
+                                 inline=additional.isInline)
+            return ([eventEmbed], [reactions + additional.get_reactions()])
 
-        return [eventEmbed] + self.createAdditionalEmbeds()
+        embeds, additional_reactions = self.createAdditionalEmbeds()
+        return ([eventEmbed] + embeds, [reactions] + additional_reactions)
 
-    def createAdditionalEmbeds(self) -> List[Embed]:
+    def createAdditionalEmbeds(self) -> Tuple[List[Embed],
+                                              List[List[ReactionEmoji]]]:
         """Creates additional embeds.
 
         The number of embeds depend on the Additional roles group"""
-        embeds = []
+        embeds: List[Embed] = []
+        all_reactions: List[List[ReactionEmoji]] = []
         group = self.roleGroups["Additional"]
 
         # Substract 1 because REACTIONS_PER_MESSAGE roles still fit in a single
@@ -292,10 +299,12 @@ def createAdditionalEmbeds(self) -> List[Embed]:
 
         for embed_number in range(embed_count):
             role_list = ""
+            reactions = []
             first = embed_number * REACTIONS_PER_MESSAGE
             last = (embed_number + 1) * REACTIONS_PER_MESSAGE
             for role in group.roles[first:last]:
                 role_list += f'{str(role)}\n'
+                reactions.append(role.emoji)
             if role_list == "":
                 # Didn't add any roles -> skipping this embed. Discord doesn't
                 # like embeds with empty fields. This should only happen if
@@ -310,8 +319,9 @@ def createAdditionalEmbeds(self) -> List[Embed]:
                                  value=role_list, inline=False)
             eventEmbed.set_footer(text="Event ID: " + str(self.id))
             embeds.append(eventEmbed)
+            all_reactions.append(reactions)
 
-        return embeds
+        return (embeds, all_reactions)
 
     # Add default role groups
     def _add_default_role_groups(self):
@@ -332,15 +342,16 @@ def _add_default_roles(self):
     def addAdditionalRole(self, name: str) -> str:
 
         # check if this role already exists
-        for roleGroup in self.roleGroups.values():
-            role: Role
-            for role in roleGroup.roles:
-                if role.name == name:
-                    raise RoleError(f"Role with name {name} already exists, "
-                                    "not adding new role")
+        try:
+            self.findRoleWithName(name)
+        except RoleNotFound:
+            pass
+        else:
+            raise RoleError(f"Role with name {name} already exists, "
+                            "not adding new role")
 
         # Find next emoji for additional role
-        if self.countReactions() >= MAX_REACTIONS:
+        if self.reaction_count >= MAX_REACTIONS:
             raise RoleError(f"Too many roles, not adding role {name}")
         emoji = cfg.ADDITIONAL_ROLE_EMOJIS[self.additional_role_count]
 
@@ -411,31 +422,25 @@ def _getNormalEmojis(self, guildEmojis) -> Dict[str, Emoji]:
 
         return normalEmojis
 
-    def getReactions(self) -> List[Union[str, Emoji]]:
+    def getReactions(self) -> List[ReactionEmoji]:
         """Return reactions of all roles and extra reactions"""
         reactions = []
 
-        for roleGroup in self.roleGroups.values():
-            role: Role
-            for role in roleGroup.roles:
-                emoji = role.emoji
-                # Skip the ZEUS reaction. Zeuses can only be signed up using
-                # the signup command
-                if not (isinstance(emoji, Emoji)
-                        and emoji.name == cfg.EMOJI_ZEUS):
-                    reactions.append(role.emoji)
+        for role_group in self.roleGroups.values():
+            reactions += role_group.get_reactions()
 
         if self.sideop:
             if cfg.ATTENDANCE_EMOJI:
                 reactions.append(cfg.ATTENDANCE_EMOJI)
 
         return reactions
 
-    def countReactions(self) -> int:
+    @property
+    def reaction_count(self) -> int:
         """Count how many reactions a message should have."""
         return len(self.getReactions())
 
-    def getReactionsOfGroup(self, groupName: str) -> List[Union[str, Emoji]]:
+    def getReactionsOfGroup(self, groupName: str) -> List[ReactionEmoji]:
         """Find reactions of a given role group."""
         reactions = []
 

eventDatabase.py

@@ -145,13 +145,14 @@ def sortEvents(cls):
             # event = sortedEvents[index]
 
             event.messageIDList = []
-            for _ in event.createEmbeds():
+            embeds, _ = event.createEmbeds()
+            for _ in embeds:
                 # Each event requires one message per embed
                 try:
                     message_id = messageIDLists.pop()
                 except IndexError:
                     # No more messages left, rest will be created later
-                    message_id = 0
+                    continue
                 event.messageIDList.append(message_id)
             cls.events[event.id] = event