highcouncil election message update.

Break out repeated code into helper function.

bot_messages/election_announcement.txt

@@ -1,5 +1,5 @@
 ```fix
-The Dakiny's admin team election
+Dakiny's Clan Council election
 ```
 Dakiny is an organization built by and for its members. We are a community of people who come together to support each other in the creation of this magical and unique experience. To sustain what we've created here, and to grow and involve into the future, we vote in our leadership every 3 months to provide an opportunity for new clan members to represent their faction of Dakiny in the Clan Council.
 

bot_messages/highcouncil_election.txt

@@ -7,7 +7,6 @@ From {highcouncil_election_announce} to {highcouncil_election_start}, you will b
  Clan Leader
  Discord Server Manager
 
-Each member of the CCE can cast one for each category by using the emotes:  <:Rank_Owner:479008325137072155>  for Clan Leader and <:Rank_Deputy:479008295319896064>  for Discord Server Manager.
+Each member of the CCE can vote once in each category (Discord Server Manager and Clan Leader). Alternatively, you may choose to intentionally abstain.
-If needed, the icon 🤷 can be used to abstain to vote in any or both categories and it should be applied to all candidates of that category.
 
 Votes can be cast until {highcouncil_election_end}, so we can announce and have everyone set up to start the term by {term_start}.

classes/election_cycle.py

@@ -6,14 +6,28 @@ import collections
 from datetime import datetime, timedelta
 
 import nextcord
-from sqlalchemy import select
+from sqlalchemy import select, true
 from sqlalchemy.orm import Session
 
+from classes.nominate_highcouncil_views import NominateHighCouncilView
 from classes.nominate_views import NominateView
+from classes.voting_highcouncil_views import VoteHighcouncilView
 from classes.voting_views import VoteView
 from config import DakinyConfig
-from database_setup.sql_data_classes import CouncilMembers, ElectionInformation, Votes, engine
+from database_setup.sql_data_classes import (
-from utils import build_votes_str, get_datetime, get_election_cycle_name
+    CouncilMembers,
+    ElectionInformation,
+    Votes,
+    engine,
+)
+from utils import (
+    build_highcouncil_votes_str,
+    build_votes_str,
+    get_cl_election_name,
+    get_datetime,
+    get_dm_election_name,
+    get_election_cycle_name,
+)
 
 
 class ElectionCycle:
@@ -40,9 +54,15 @@ class ElectionCycle:
         self.term_end: datetime = get_datetime(self.election_cycle.term_end)
         self.voting_start: datetime = get_datetime(self.election_cycle.voting_start)
         self.voting_end: datetime = get_datetime(self.election_cycle.voting_end)
-        self.highcouncil_election_announce: datetime = get_datetime(self.election_cycle.highcouncil_election_announce)
+        self.highcouncil_election_announce: datetime = get_datetime(
-        self.highcouncil_election_start: datetime = get_datetime(self.election_cycle.highcouncil_election_start)
+            self.election_cycle.highcouncil_election_announce
-        self.highcouncil_election_end: datetime = get_datetime(self.election_cycle.highcouncil_election_end)
+        )
+        self.highcouncil_election_start: datetime = get_datetime(
+            self.election_cycle.highcouncil_election_start
+        )
+        self.highcouncil_election_end: datetime = get_datetime(
+            self.election_cycle.highcouncil_election_end
+        )
         self.guild: nextcord.Guild = guild
         self.election_over: bool = False
 
@@ -55,11 +75,15 @@ class ElectionCycle:
             long.
         """
 
-        with open("bot_messages/election_announcement.txt", mode="r", encoding="utf8") as file:
+        with open(
+            "bot_messages/election_announcement.txt", mode="r", encoding="utf8"
+        ) as file:
             message = file.read()
 
             next_election = get_datetime(
-                self.config.election_cycles[(self.cycle + 1) % len(self.config.election_cycles)].election_start
+                self.config.election_cycles[
+                    (self.cycle + 1) % len(self.config.election_cycles)
+                ].election_start
             )
 
             message = message.format(
@@ -84,14 +108,22 @@ class ElectionCycle:
             str: Message to send.
         """
 
-        with open("bot_messages/highcouncil_election.txt", mode="r", encoding="utf8") as file:
+        with open(
+            "bot_messages/highcouncil_election.txt", mode="r", encoding="utf8"
+        ) as file:
             message = file.read()
 
             return message.format(
                 clan_council_elect_role_id=self.config.params.clan_council_elect_role_id,
-                highcouncil_election_announce=self.highcouncil_election_announce.strftime("%B %d"),
+                highcouncil_election_announce=self.highcouncil_election_announce.strftime(
-                highcouncil_election_start=self.highcouncil_election_start.strftime("%B %d"),
+                    "%B %d"
-                highcouncil_election_end=self.highcouncil_election_end.strftime("%B %d"),
+                ),
+                highcouncil_election_start=self.highcouncil_election_start.strftime(
+                    "%B %d"
+                ),
+                highcouncil_election_end=self.highcouncil_election_end.strftime(
+                    "%B %d"
+                ),
                 term_start=self.term_start.strftime("%B %d"),
             )
 
@@ -103,7 +135,9 @@ class ElectionCycle:
             str: Message to send.
         """
 
-        with open("bot_messages/highcouncil_vote.txt", mode="r", encoding="utf8") as file:
+        with open(
+            "bot_messages/highcouncil_vote.txt", mode="r", encoding="utf8"
+        ) as file:
             message = file.read()
 
             return message.format(
@@ -121,7 +155,9 @@ class ElectionCycle:
 
         with open("bot_messages/vote_start.txt", mode="r", encoding="utf8") as file:
             message = file.read()
-            vote_end: datetime = get_datetime(self.config.election_cycles[self.cycle].voting_end)
+            vote_end: datetime = get_datetime(
+                self.config.election_cycles[self.cycle].voting_end
+            )
 
             return message.format(
                 clan_member_id=self.config.params.clan_member_role_id,
@@ -140,7 +176,11 @@ class ElectionCycle:
             await self.election_start_action()
         elif today.date() == self.voting_start.date():
             await self.voting_start_action()
-        elif (self.voting_end - timedelta(3)).date() <= today.date() < self.voting_end.date():
+        elif (
+            (self.voting_end - timedelta(3)).date()
+            <= today.date()
+            < self.voting_end.date()
+        ):
             await self.election_reminder()
         elif today.date() == self.voting_end.date():
             await self.voting_end_action()
@@ -154,17 +194,16 @@ class ElectionCycle:
         Performs required actions for when the election cycle starts.
         """
         # create new channel for election
-        category: nextcord.CategoryChannel = self.guild.get_channel(self.config.params.active_category_id)
+        parent: nextcord.TextChannel = self.guild.get_channel(
+            self.config.params.voting_parent_id
+        )
         quarter_name: str = get_election_cycle_name(self.config)
 
-        # create new entry into database.
+        thread_msg: nextcord.Message = await parent.send(content=quarter_name)
-        election_channel: nextcord.TextChannel = await category.create_text_channel(quarter_name)
+
-        clan_member_role: nextcord.Role = self.guild.get_role(self.config.params.clan_member_role_id)
+        thread: nextcord.Thread = await parent.create_thread(
-        await election_channel.set_permissions(clan_member_role, add_reactions=True)
+            name=quarter_name, message=thread_msg
-        with Session(engine) as session:
+        )
-            new_cycle = ElectionInformation(ElectionCycle=quarter_name, ElectionChannel=election_channel.id)
-            session.add(new_cycle)
-            session.commit()
 
         # post message announcing election
         # election start message is returned as an array of string because it is too long. send each string
@@ -173,9 +212,21 @@ class ElectionCycle:
         for index, message in enumerate(messages):
             # if last item, add the nominate button
             if index + 1 == len(messages):
-                await election_channel.send(message, view=NominateView(self.config))
+                nominate_msg: nextcord.Message = await thread.send(
+                    message, view=NominateView(self.config, self.guild)
+                )
             else:
-                await election_channel.send(message)
+                await thread.send(message)
+
+        # create new entry into database.
+        with Session(engine) as session:
+            new_cycle = ElectionInformation(
+                ElectionCycle=quarter_name,
+                ThreadId=thread.id,
+                CouncilNominationMsgId=nominate_msg.id,
+            )
+            session.add(new_cycle)
+            session.commit()
 
     async def voting_start_action(self) -> None:
         """
@@ -183,20 +234,28 @@ class ElectionCycle:
         Removes write permission from the general clan member role.
         """
         message = self.build_vote_start()
-        clan_member_role: nextcord.Role = self.guild.get_role(self.config.params.clan_member_role_id)
+        election_thread: nextcord.Thread = self.guild.get_thread(
-        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+            self.get_election_info().ThreadId
-        await election_channel.send(message)
+        )
-        vote_msg = await election_channel.send(build_votes_str(self.config), view=VoteView(self.config, self.guild))
+        await election_thread.send(message)
+        vote_msg = await election_thread.send(
+            build_votes_str(self.config), view=VoteView(self.config, self.guild)
+        )
 
         with Session(engine) as session:
             stmt = select(ElectionInformation).where(
-                ElectionInformation.ElectionCycle == get_election_cycle_name(self.config)
+                ElectionInformation.ElectionCycle
+                == get_election_cycle_name(self.config)
             )
             info = session.scalar(stmt)
             info.CouncilVoteMsgId = vote_msg.id
             session.commit()
 
-        await election_channel.set_permissions(clan_member_role, send_messages=False)
+            thread: nextcord.Thread = self.guild.get_thread(info.ThreadId)
+            nominate_msg: nextcord.Message = await thread.fetch_message(
+                info.CouncilNominationMsgId
+            )
+            await nominate_msg.edit(view=None)
 
     async def voting_end_action(self) -> None:
         """
@@ -204,22 +263,35 @@ class ElectionCycle:
         """
 
         message = self.build_highcouncil_election_announce()
-        council_elect_role: nextcord.Role = self.guild.get_role(self.config.params.clan_council_elect_role_id)
+        council_elect_role: nextcord.Role = self.guild.get_role(
-        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+            self.config.params.clan_council_elect_role_id
-        clan_member_role: nextcord.Role = self.guild.get_role(self.config.params.clan_member_role_id)
+        )
+        election_thread: nextcord.Thread = self.guild.get_thread(
+            self.get_election_info().ThreadId
+        )
+
+        nominate_msg: nextcord.Message = await election_thread.send(
+            message, view=NominateHighCouncilView(self.config, self.guild)
+        )
 
-        # remove vote button from vote message
         election_name = get_election_cycle_name(self.config)
+
         with Session(engine) as session:
-            stmt = select(ElectionInformation.CouncilVoteMsgId).where(
+            # remove vote button from vote message
+            stmt = select(ElectionInformation).where(
                 ElectionInformation.ElectionCycle == election_name
             )
-            vote_msg_id = session.scalar(stmt)
+            info = session.scalar(stmt)
-        vote_msg: nextcord.Message = await election_channel.fetch_message(vote_msg_id)
+            vote_msg: nextcord.Message = await election_thread.fetch_message(
+                info.CouncilVoteMsgId
+            )
             await vote_msg.edit(view=None)
 
+            # add the highcouncil nomination message to election information
+            info.HighCouncilNominationMsgId = nominate_msg.id
+            session.commit()
+
             # add the highcouncil role to everyone with 3 or more votes. set elected to true in database
-        with Session(engine) as session:
             stmt = select(Votes.VotedForId).where(Votes.ElectionCycle == election_name)
             vote_count = collections.Counter(session.scalars(stmt))
 
@@ -234,13 +306,12 @@ class ElectionCycle:
                     council_member.Elected = True
                     session.commit()
 
-                    user: nextcord.Member = self.guild.get_member(user_id)
+                    member: nextcord.Member = self.guild.get_member(user_id)
 
-                    await user.add_roles(council_elect_role)
+                    await member.add_roles(
-
+                        council_elect_role,
-        await election_channel.send(message)
+                        reason=f"{member.display_name} has won a nomination and become a Council Elect.",
-        await election_channel.set_permissions(council_elect_role, send_messages=True, add_reactions=True)
+                    )
-        await election_channel.set_permissions(clan_member_role, add_reactions=False)
 
     async def highcouncil_election_start_action(self) -> None:
         """
@@ -248,19 +319,104 @@ class ElectionCycle:
         """
 
         message = self.build_highcouncil_vote_start()
-        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+        election_thread: nextcord.Thread = self.guild.get_thread(
-        await election_channel.send(message)
+            self.get_election_info().ThreadId
+        )
+        await election_thread.send(message)
+        vote_msg = await election_thread.send(
+            build_highcouncil_votes_str(self.config),
+            view=VoteHighcouncilView(self.config, self.guild),
+        )
+
+        with Session(engine) as session:
+            stmt = select(ElectionInformation).where(
+                ElectionInformation.ElectionCycle
+                == get_election_cycle_name(self.config)
+            )
+            info = session.scalar(stmt)
+            info.HighCouncilVoteMsgId = vote_msg.id
+            session.commit()
+
+            # remove highcouncil nomination view
+            nomination_msg: nextcord.Message = await election_thread.fetch_message(
+                info.HighCouncilNominationMsgId
+            )
+            await nomination_msg.edit(view=None)
 
     async def term_start_action(self) -> None:
         """
-        Moves the election channel into the archive category.
+        Marks the election as over.
         """
 
         self.election_over = True
-        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
-        archive: nextcord.CategoryChannel = self.guild.get_channel(self.config.params.archive_channel_group_id)
 
-        await election_channel.move(beginning=True, category=archive)
+        elect_role: nextcord.Role = self.guild.get_role(
+            self.config.params.clan_council_elect_role_id
+        )
+        council_role: nextcord.Role = self.guild.get_role(
+            self.config.params.clan_council_role_id
+        )
+
+        with Session(engine) as session:
+            # role management
+            stmt = (
+                select(CouncilMembers.MemberId)
+                .where(
+                    CouncilMembers.ElectionCycle == get_election_cycle_name(self.config)
+                )
+                .where(CouncilMembers.Elected == true())
+            )
+
+            for member_id in session.scalars(stmt):
+                member = self.guild.get_member(member_id)
+                await member.remove_roles(
+                    elect_role,
+                    reason=f"{member.display_name} no longer needs the elect role.",
+                )
+                await member.add_roles(
+                    council_role,
+                    reason=f"{member.display_name} has been elected to council.",
+                )
+
+            # announce high council members
+            # ties are undefined behavior.
+            dm_election = get_dm_election_name(self.config)
+            cl_election = get_cl_election_name(self.config)
+            stmt = select(Votes.VotedForId).where(Votes.ElectionCycle == dm_election)
+            dm_votes = collections.Counter(session.scalars(stmt))
+            stmt = select(Votes.VotedForId).where(Votes.ElectionCycle == cl_election)
+            cl_votes = collections.Counter(session.scalars(stmt))
+
+            try:
+                dm_winner = max(dm_votes, key=dm_votes.get)
+            except ValueError:
+                dm_winner = "No winner"
+            try:
+                cl_winner = max(cl_votes, key=cl_votes.get)
+            except ValueError:
+                cl_winner = "No winner"
+
+        election_thread: nextcord.Thread = self.guild.get_thread(
+            self.get_election_info().ThreadId
+        )
+
+        # clear view from vote message
+        stmt = select(ElectionInformation.HighCouncilVoteMsgId).where(
+            ElectionInformation.ElectionCycle == get_election_cycle_name(self.config)
+        )
+        vote_msg_id = session.scalar(stmt)
+        vote_msg: nextcord.Message = await election_thread.fetch_message(vote_msg_id)
+        await vote_msg.edit(view=None)
+
+        highcouncil_msg: str = f"Congratulations for our high council members!\n Clan Leader: <@{cl_winner}>\n"
+        highcouncil_msg += f"Discord Manager: <@{dm_winner}>"
+        await election_thread.send(highcouncil_msg)
+
+        await election_thread.send(
+            "This election cycle is now over. Thank you everyone for participating!"
+        )
+
+        await election_thread.edit(archived=True, locked=True)
 
     def get_election_info(self) -> ElectionInformation:
         """
@@ -272,7 +428,8 @@ class ElectionCycle:
 
         with Session(engine) as session:
             stmt = select(ElectionInformation).where(
-                ElectionInformation.ElectionCycle == get_election_cycle_name(self.config)
+                ElectionInformation.ElectionCycle
+                == get_election_cycle_name(self.config)
             )
             return session.scalar(stmt)
 
@@ -281,9 +438,11 @@ class ElectionCycle:
         Sends a message to general chat reminder clan about election.
         """
 
-        general: nextcord.TextChannel = self.guild.get_channel(self.config.params.general_channel_id)
+        general: nextcord.TextChannel = self.guild.get_channel(
+            self.config.params.general_channel_id
+        )
 
         message = f"Reminder to <@&{self.config.params.clan_member_role_id}>! Clan elections are happening! Head over "
-        message += f"to <#{self.get_election_info().ElectionChannel}> to cast your vote!"
+        message += f"to <#{self.get_election_info().ThreadId}> to cast your vote!"
 
         await general.send(content=message)

classes/nominate_highcouncil_views.py

@@ -0,0 +1,266 @@
+"""
+Contains various views to be used in the high council nomination process.
+"""
+
+import nextcord
+from nextcord.interactions import Interaction
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from config import DakinyConfig
+from database_setup.sql_data_classes import CouncilMembers, engine
+from utils import (
+    NOMINEE_SPLITTER,
+    decorate_cl_nomination,
+    decorate_dm_nomination,
+    get_election_cycle_name,
+)
+
+
+class NominateDMModal(nextcord.ui.Modal):
+    """
+    Modal for nominating oneself. User writes a speech and then the callback sends the speech into the correct channel.
+    """
+
+    def __init__(
+        self,
+        config: DakinyConfig,
+        usr_id: int,
+        usr_nominated: bool,
+        speech_content: str,
+    ):
+        super().__init__(
+            "Discord Manager Nomination",
+            timeout=5 * 60,  # 5 minutes
+        )
+        self.usr_id: int = usr_id
+        self.config: DakinyConfig = config
+        self.usr_nominated = usr_nominated
+
+        self.speech = nextcord.ui.TextInput(
+            label="Nomination Speech",
+            style=nextcord.TextInputStyle.paragraph,
+            placeholder="Please write your speech here.",
+            required=True,
+            max_length=1500,
+            default_value=speech_content,
+        )
+        self.add_item(self.speech)
+
+    async def callback(self, interaction: Interaction) -> None:
+        """
+        Sends the nomination speech into the voting channel and enters the user into the voting database.
+
+        Args:
+            interaction (Interaction): Interaction with user.
+
+        """
+
+        speech = decorate_dm_nomination(interaction.user.id, self.speech.value)
+
+        with Session(engine) as session:
+            # user already in table
+            cycle = get_election_cycle_name(self.config)
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionCycle == cycle)
+                .where(CouncilMembers.MemberId == self.usr_id)
+            )
+            council_elect = session.scalar(stmt)
+
+            if not self.usr_nominated:
+                msg = await interaction.channel.send(speech)
+
+                council_elect.DiscordManagerSpeechId = msg.id
+                session.commit()
+            else:
+                msg: nextcord.Message = await interaction.channel.fetch_message(
+                    council_elect.DiscordManagerSpeechId
+                )
+                await msg.edit(
+                    content=decorate_dm_nomination(
+                        interaction.user.id, self.speech.value
+                    )
+                )
+
+
+class NominateCLModal(nextcord.ui.Modal):
+    """
+    Modal for nominating oneself. User writes a speech and then the callback sends the speech into the correct channel.
+    """
+
+    def __init__(
+        self,
+        config: DakinyConfig,
+        usr_id: int,
+        usr_nominated: bool,
+        speech_content: str,
+    ):
+        super().__init__(
+            "Clan Leader Nomination",
+            timeout=5 * 60,  # 5 minutes
+        )
+        self.usr_id: int = usr_id
+        self.config: DakinyConfig = config
+        self.usr_nominated = usr_nominated
+
+        self.speech = nextcord.ui.TextInput(
+            label="Nomination Speech",
+            style=nextcord.TextInputStyle.paragraph,
+            placeholder="Please write your speech here.",
+            required=True,
+            max_length=1500,
+            default_value=speech_content,
+        )
+        self.add_item(self.speech)
+
+    async def callback(self, interaction: Interaction) -> None:
+        """
+        Sends the nomination speech into the voting channel and enters the user into the voting database.
+
+        Args:
+            interaction (Interaction): Interaction with user.
+
+        """
+
+        speech = decorate_cl_nomination(interaction.user.id, self.speech.value)
+
+        with Session(engine) as session:
+            # user already in table
+            cycle = get_election_cycle_name(self.config)
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionCycle == cycle)
+                .where(CouncilMembers.MemberId == self.usr_id)
+            )
+            council_elect = session.scalar(stmt)
+
+            if not self.usr_nominated:
+                msg = await interaction.channel.send(speech)
+
+                council_elect.ClanLeaderSpeechId = msg.id
+                session.commit()
+            else:
+                msg: nextcord.Message = await interaction.channel.fetch_message(
+                    council_elect.ClanLeaderSpeechId
+                )
+                await msg.edit(
+                    content=decorate_cl_nomination(
+                        interaction.user.id, self.speech.value
+                    )
+                )
+
+
+class NominateHighCouncilView(nextcord.ui.View):
+    """
+    The buttons to press to start your High Council nomination.
+    """
+
+    def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
+        super().__init__(timeout=None)
+        self.config: DakinyConfig = config
+        self.guild: nextcord.Guild = guild
+
+    @nextcord.ui.button(
+        label="Nominate for Discord Manager",
+        style=nextcord.ButtonStyle.primary,
+        custom_id="nominate-dm",
+    )
+    async def nominate_dm(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
+        """
+        Gathers previous information about the user if they have already nominated themselves, then launches
+        the nomination modal to get their speech.
+
+        Args:
+            button (nextcord.ui.Button): Unused. idk why its needed in the decorator
+            interaction (nextcord.Interaction): Interaction of user who pressed the button
+        """
+
+        # enforce council elect only
+        if (
+            self.guild.get_role(self.config.params.clan_council_elect_role_id)
+            not in interaction.user.roles
+        ):
+            await interaction.response.send_message(
+                f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        cycle = get_election_cycle_name(self.config)
+        usr_nominated = False
+        speech_content = ""
+        with Session(engine) as session:
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionCycle == cycle)
+                .where(CouncilMembers.MemberId == interaction.user.id)
+            )
+            obj = session.scalar(stmt)
+
+            # user needs to exist to get here anyways...
+            if obj.DiscordManagerSpeechId is not None:
+                usr_nominated = True
+                msg = await interaction.channel.fetch_message(
+                    obj.DiscordManagerSpeechId
+                )
+                speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
+
+        await interaction.response.send_modal(
+            NominateDMModal(
+                self.config, interaction.user.id, usr_nominated, speech_content
+            )
+        )
+
+    @nextcord.ui.button(
+        label="Nominate for Clan Leader",
+        style=nextcord.ButtonStyle.primary,
+        custom_id="nominate-cl",
+    )
+    async def nominate_cl(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
+        """
+        Gathers previous information about the user if they have already nominated themselves, then launches
+        the nomination modal to get their speech.
+
+        Args:
+            button (nextcord.ui.Button): Unused. idk why its needed in the decorator
+            interaction (nextcord.Interaction): Interaction of user who pressed the button
+        """
+
+        # enforce council elect only
+        if (
+            self.guild.get_role(self.config.params.clan_council_elect_role_id)
+            not in interaction.user.roles
+        ):
+            await interaction.response.send_message(
+                f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        cycle = get_election_cycle_name(self.config)
+        usr_nominated = False
+        speech_content = ""
+        with Session(engine) as session:
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionCycle == cycle)
+                .where(CouncilMembers.MemberId == interaction.user.id)
+            )
+            obj = session.scalar(stmt)
+
+            # user needs to exist to get here anyways...
+            if obj.ClanLeaderSpeechId is not None:
+                usr_nominated = True
+                msg = await interaction.channel.fetch_message(obj.ClanLeaderSpeechId)
+                speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
+
+        await interaction.response.send_modal(
+            NominateCLModal(
+                self.config, interaction.user.id, usr_nominated, speech_content
+            )
+        )

classes/nominate_views.py

@@ -9,9 +9,7 @@ from sqlalchemy.orm import Session
 
 from config import DakinyConfig
 from database_setup.sql_data_classes import CouncilMembers, engine
-from utils import get_election_cycle_name
+from utils import NOMINEE_SPLITTER, decorate_nomination, get_election_cycle_name
-
-NOMINEE_SPLITTER = "========================================================\n\n"
 
 
 class NominateModal(nextcord.ui.Modal):
@@ -19,7 +17,13 @@ class NominateModal(nextcord.ui.Modal):
     Modal for nominating oneself. User writes a speech and then the callback sends the speech into the correct channel.
     """
 
-    def __init__(self, config: DakinyConfig, usr_id: int, usr_nominated: bool, speech_content: str):
+    def __init__(
+        self,
+        config: DakinyConfig,
+        usr_id: int,
+        usr_nominated: bool,
+        speech_content: str,
+    ):
         super().__init__(
             "Nomination",
             timeout=5 * 60,  # 5 minutes
@@ -69,10 +73,13 @@ class NominateModal(nextcord.ui.Modal):
                     .where(CouncilMembers.MemberId == self.usr_id)
                 )
                 obj = session.scalar(stmt)
-                obj.SpeechMsgContents = self.speech.value
 
-                msg: nextcord.Message = await interaction.channel.fetch_message(obj.SpeechMsgId)
+                msg: nextcord.Message = await interaction.channel.fetch_message(
-                await msg.edit(content=decorate_nomination(interaction.user.id, self.speech.value))
+                    obj.SpeechMsgId
+                )
+                await msg.edit(
+                    content=decorate_nomination(interaction.user.id, self.speech.value)
+                )
 
 
 class NominateView(nextcord.ui.View):
@@ -80,12 +87,19 @@ class NominateView(nextcord.ui.View):
     The button to press to start your nomination.
     """
 
-    def __init__(self, config):
+    def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
         super().__init__(timeout=None)
         self.config: DakinyConfig = config
+        self.guild: nextcord.Guild = guild
 
-    @nextcord.ui.button(label="Nominate Yourself", style=nextcord.ButtonStyle.primary, custom_id="nominate")
+    @nextcord.ui.button(
-    async def nominate(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:
+        label="Nominate Yourself",
+        style=nextcord.ButtonStyle.primary,
+        custom_id="nominate",
+    )
+    async def nominate(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
         """
         Gathers previous information about the user if they have already nominated themselves, then launches
         the nomination modal to get their speech.
@@ -95,6 +109,17 @@ class NominateView(nextcord.ui.View):
             interaction (nextcord.Interaction): Interaction of user who pressed the button
         """
 
+        # enforce members only
+        if (
+            self.guild.get_role(self.config.params.clan_member_role_id)
+            not in interaction.user.roles
+        ):
+            await interaction.response.send_message(
+                f"You must have the <@&{self.config.params.clan_member_role_id}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
         cycle = get_election_cycle_name(self.config)
         usr_nominated = False
         speech_content = ""
@@ -111,23 +136,7 @@ class NominateView(nextcord.ui.View):
                 speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
 
         await interaction.response.send_modal(
-            NominateModal(self.config, interaction.user.id, usr_nominated, speech_content)
+            NominateModal(
+                self.config, interaction.user.id, usr_nominated, speech_content
+            )
         )
-
-
-def decorate_nomination(user_id, speech) -> str:
-    """
-    Decorates a nomination speech so that it sits within multiple speeches better.
-
-    Args:
-        user_id (_type_): ID of user sending the speech
-        speech (_type_): Speech from the user
-
-    Returns:
-        str: Decorated speech
-    """
-    msg = f"**Clan Council Nominee: <@{user_id}>**\n"
-    msg += NOMINEE_SPLITTER
-    msg += speech
-
-    return msg

classes/voting_highcouncil_views.py

@@ -0,0 +1,253 @@
+"""
+Contains various views to be used while voting for high council. Controls the logic when performing the vote.
+"""
+
+from typing import List
+
+import nextcord
+from nextcord import SelectOption
+from nextcord.interactions import Interaction
+from sqlalchemy import exc, select, update
+from sqlalchemy.orm import Session
+
+from config import DakinyConfig
+from database_setup.sql_data_classes import (
+    CouncilMembers,
+    ElectionInformation,
+    Votes,
+    engine,
+)
+from utils import (
+    build_highcouncil_votes_str,
+    get_cl_election_name,
+    get_dm_election_name,
+    get_election_cycle_name,
+)
+
+
+class VoteSelect(nextcord.ui.StringSelect):
+    def __init__(
+        self, options: List["SelectOption"], config: DakinyConfig, election_type: str
+    ) -> None:
+        super().__init__(
+            placeholder="Choose 1",
+            min_values=1,
+            max_values=1,
+            options=options,
+        )
+        self.config = config
+        self.election_type = election_type
+
+    async def callback(self, interaction: Interaction):
+        # decide on election type
+        match self.election_type:
+            case "cl":
+                election_name: str = get_cl_election_name(self.config)
+            case "dm":
+                election_name: str = get_dm_election_name(self.config)
+            case _:
+                # should never happen
+                raise ValueError('election type was not "cl" or "dm"')
+
+        cycle: str = get_election_cycle_name(self.config)
+        with Session(engine) as session:
+            stmt = select(ElectionInformation.HighCouncilVoteMsgId).where(
+                ElectionInformation.ElectionCycle == cycle
+            )
+            vote_msg_id = session.scalar(stmt)
+
+            if self.values[0] == "Abstain":
+                voted_for = None
+            else:
+                voted_for = int(self.values[0])
+
+            new_vote = Votes(
+                ElectionCycle=election_name,
+                VoterId=interaction.user.id,
+                VotedForId=voted_for,
+            )
+
+            try:
+                session.add(new_vote)
+                session.commit()
+
+            except exc.IntegrityError:
+                session.rollback()
+                stmt = (
+                    update(Votes)
+                    .where(Votes.ElectionCycle == election_name)
+                    .where(Votes.VoterId == interaction.user.id)
+                    .values(VotedForId=voted_for)
+                )
+                session.execute(stmt)
+                session.commit()
+
+        vote_message_str = build_highcouncil_votes_str(self.config)
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(
+            vote_msg_id
+        )
+        await vote_msg.edit(content=vote_message_str)
+
+        if voted_for is not None:
+            msg = f"You have voted for <@{voted_for}>"
+        else:
+            msg = "You have abstained from voting."
+
+        await interaction.edit(content=msg, view=None)
+
+
+class VoteHighcouncilView(nextcord.ui.View):
+    """
+    The button to press to start voting for HighCouncil.
+    """
+
+    def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
+        super().__init__(timeout=None)
+        self.config = config
+        self.guild = guild
+
+    @nextcord.ui.button(
+        label="Vote for Clan Leader",
+        style=nextcord.ButtonStyle.primary,
+        custom_id="vote-cl",
+    )
+    async def vote_cl(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
+        """
+        Enforces only council elect vote. Gets election cycle, creates voting
+        options for clan leader (checking if user has voted already),
+        then sends the voting view.
+
+        Args:
+            button (nextcord.ui.Button): Unused. idk why its needed in the decorator
+            interaction (nextcord.Interaction): Interaction of user who pressed the button
+        """
+
+        # enforce council elect only
+        if (
+            self.guild.get_role(self.config.params.clan_council_elect_role_id)
+            not in interaction.user.roles
+        ):
+            await interaction.response.send_message(
+                f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        cycle: str = get_election_cycle_name(self.config)
+        election: str = get_cl_election_name(self.config)
+
+        with Session(engine) as session:
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionCycle == election)
+                .where(Votes.VoterId == interaction.user.id)
+            )
+            voted_for = session.scalar(stmt)
+
+            stmt = (
+                select(CouncilMembers.MemberId)
+                .where(CouncilMembers.ElectionCycle == cycle)
+                .filter(CouncilMembers.ClanLeaderSpeechId.is_not(None))
+            )
+
+            options = [
+                SelectOption(
+                    label=f"{self.guild.get_member(nominee).display_name} ☑️"
+                    if voted_for == nominee
+                    else f"{self.guild.get_member(nominee).display_name}",
+                    value=str(nominee),
+                )
+                for nominee in session.scalars(stmt)
+            ]
+            options.append(
+                SelectOption(
+                    label="Abstain ☑️" if voted_for is None else "Abstain",
+                    value="Abstain",
+                )
+            )
+
+        view = nextcord.ui.View()
+        view.add_item(
+            VoteSelect(options=options, config=self.config, election_type="cl")
+        )
+
+        await interaction.response.send_message(
+            content="Please vote for a Clan Leader!",
+            view=view,
+            ephemeral=True,
+        )
+
+    @nextcord.ui.button(
+        label="Vote for Discord Manager",
+        style=nextcord.ButtonStyle.primary,
+        custom_id="vote-dm",
+    )
+    async def vote_dm(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
+        """
+        Enforces only council elect vote. Gets election cycle, creates voting
+        options for discord manager (checking if user has voted already),
+        then sends the voting view.
+
+        Args:
+            button (nextcord.ui.Button): Unused. idk why its needed in the decorator
+            interaction (nextcord.Interaction): Interaction of user who pressed the button
+        """
+
+        # enforce council elect only
+        if (
+            self.guild.get_role(self.config.params.clan_council_elect_role_id)
+            not in interaction.user.roles
+        ):
+            await interaction.response.send_message(
+                f"You must have the <@&{self.config.params.clan_council_elect_role_id}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        cycle: str = get_election_cycle_name(self.config)
+        election: str = get_dm_election_name(self.config)
+
+        with Session(engine) as session:
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionCycle == election)
+                .where(Votes.VoterId == interaction.user.id)
+            )
+            voted_for = session.scalar(stmt)
+
+            stmt = (
+                select(CouncilMembers.MemberId)
+                .where(CouncilMembers.ElectionCycle == cycle)
+                .filter(CouncilMembers.DiscordManagerSpeechId.is_not(None))
+            )
+
+            options = [
+                SelectOption(
+                    label=f"{self.guild.get_member(nominee).display_name} ☑️"
+                    if voted_for == nominee
+                    else f"{self.guild.get_member(nominee).display_name}",
+                    value=str(nominee),
+                )
+                for nominee in session.scalars(stmt)
+            ]
+            options.append(
+                SelectOption(
+                    label="Abstain ☑️" if voted_for is None else "Abstain",
+                    value="Abstain",
+                )
+            )
+
+        view = nextcord.ui.View()
+        view.add_item(
+            VoteSelect(options=options, config=self.config, election_type="dm")
+        )
+
+        await interaction.response.send_message(
+            content="Please vote for a Discord Manager!",
+            view=view,
+            ephemeral=True,
+        )

classes/voting_views.py

@@ -7,11 +7,16 @@ from typing import List
 import nextcord
 from nextcord import SelectOption
 from nextcord.interactions import Interaction
-from sqlalchemy import exc, select
+from sqlalchemy import exc, select, update
 from sqlalchemy.orm import Session
 
 from config import DakinyConfig
-from database_setup.sql_data_classes import CouncilMembers, ElectionInformation, Votes, engine
+from database_setup.sql_data_classes import (
+    CouncilMembers,
+    ElectionInformation,
+    Votes,
+    engine,
+)
 from utils import build_votes_str, get_election_cycle_name
 
 
@@ -38,7 +43,11 @@ class VoteSelect(nextcord.ui.StringSelect):
             else:
                 voted_for = int(self.values[0])
 
-            new_vote = Votes(ElectionCycle=election_name, VoterId=interaction.user.id, VotedForId=voted_for)
+            new_vote = Votes(
+                ElectionCycle=election_name,
+                VoterId=interaction.user.id,
+                VotedForId=voted_for,
+            )
 
             try:
                 session.add(new_vote)
@@ -47,16 +56,18 @@ class VoteSelect(nextcord.ui.StringSelect):
             except exc.IntegrityError:
                 session.rollback()
                 stmt = (
-                    select(Votes)
+                    update(Votes)
                     .where(Votes.ElectionCycle == election_name)
                     .where(Votes.VoterId == interaction.user.id)
+                    .values(VotedForId=voted_for)
                 )
-                vote = session.scalar(stmt)
+                session.execute(stmt)
-                vote.VotedForId = voted_for
                 session.commit()
 
         vote_message_str = build_votes_str(self.config)
-        vote_msg: nextcord.Message = await interaction.channel.fetch_message(vote_msg_id)
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(
+            vote_msg_id
+        )
         await vote_msg.edit(content=vote_message_str)
 
         if voted_for is not None:
@@ -77,10 +88,15 @@ class VoteView(nextcord.ui.View):
         self.config = config
         self.guild = guild
 
-    @nextcord.ui.button(label="Vote", style=nextcord.ButtonStyle.primary, custom_id="vote")
+    @nextcord.ui.button(
-    async def vote(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:
+        label="Vote", style=nextcord.ButtonStyle.primary, custom_id="vote"
+    )
+    async def vote(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ) -> None:
         """
-        TODO
+        Enforces only members vote. Gets election cycle, creates voting options (checking if user has voted already),
+        then sends the voting view.
 
         Args:
             button (nextcord.ui.Button): Unused. idk why its needed in the decorator
@@ -88,9 +104,13 @@ class VoteView(nextcord.ui.View):
         """
 
         # enforce members only
-        if self.guild.get_role(self.config.params.clan_member_role_id) not in interaction.user.roles:
+        if (
+            self.guild.get_role(self.config.params.clan_member_role_id)
+            not in interaction.user.roles
+        ):
             await interaction.response.send_message(
-                f"You must have the <@&{self.config.params.clan_member_role_id}> role to vote.", ephemeral=True
+                f"You must have the <@&{self.config.params.clan_member_role_id}> role to vote.",
+                ephemeral=True,
             )
             return
 
@@ -104,18 +124,25 @@ class VoteView(nextcord.ui.View):
             )
             voted_for = session.scalar(stmt)
 
-            stmt = select(CouncilMembers.MemberId).where(CouncilMembers.ElectionCycle == election)
+            stmt = select(CouncilMembers.MemberId).where(
+                CouncilMembers.ElectionCycle == election
+            )
 
             options = [
                 SelectOption(
-                    label=f"{self.guild.get_member(nominee).nick} ☑️"
+                    label=f"{self.guild.get_member(nominee).display_name} ☑️"
                     if voted_for == nominee
-                    else f"{self.guild.get_member(nominee).nick}",
+                    else f"{self.guild.get_member(nominee).display_name}",
                     value=str(nominee),
                 )
                 for nominee in session.scalars(stmt)
             ]
-            options.append(SelectOption(label="Abstain ☑️" if voted_for is None else "Abstain", value="Abstain"))
+            options.append(
+                SelectOption(
+                    label="Abstain ☑️" if voted_for is None else "Abstain",
+                    value="Abstain",
+                )
+            )
 
         view = nextcord.ui.View()
         view.add_item(VoteSelect(options=options, config=self.config))

cogs/commands/__init__.py

@@ -7,6 +7,7 @@ from nextcord.ext import commands
 from cogs.commands.request import RequestCog
 from cogs.commands.set import setCog
 from cogs.commands.test import TestCog
+from cogs.commands.view import ViewCog
 
 
 # This function will be called when this extension is loaded.
@@ -19,3 +20,4 @@ def setup(bot: commands.Bot):
     bot.add_cog(RequestCog(bot))
     bot.add_cog(TestCog(bot))
     bot.add_cog(setCog())
+    bot.add_cog(ViewCog())

cogs/commands/test.py

@@ -10,6 +10,17 @@ from config import DakinyConfig
 from utils import get_current_cycle
 
 
+def is_me():
+    """
+    predicate that makes sure only I can run the test commands.
+    """
+
+    def predicate(interaction: nextcord.Interaction):
+        return interaction.user.id == 206602713511886849
+
+    return application_checks.check(predicate)
+
+
 class TestCog(commands.Cog, name="Test commands."):
     """
     Class holds commands for testing.
@@ -21,37 +32,14 @@ class TestCog(commands.Cog, name="Test commands."):
         """
         self.bot = bot
 
-    def is_me():
+    @nextcord.slash_command(guild_ids=[1000247361639030804])
-        def predicate(interaction: nextcord.Interaction):
-            return interaction.user.id == 206602713511886849
-
-        return application_checks.check(predicate)
-
-    @nextcord.slash_command()
-    @is_me()
     async def test(self, interaction: nextcord.Interaction):
         """
         Parent slash command for help. Never called.
         """
 
     @test.subcommand()
-    async def msg_builder(self, interaction: nextcord.Interaction):
+    @is_me()
-        """
-        Tests the message builder.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction that invoked the command.
-        """
-
-        cycle = ElectionCycle(0, self.bot)
-
-        message = cycle.build_election_announcement()
-
-        # doesn't tell discord that the message was responded to. Is a test command so I don't really care atm.
-        for m in message:
-            await interaction.channel.send(content=m)
-
-    @test.subcommand()
     async def election_start(self, interaction: nextcord.Interaction):
         """
         idc
@@ -61,10 +49,15 @@ class TestCog(commands.Cog, name="Test commands."):
         """
 
         config: DakinyConfig = self.bot.config
-        cycle = ElectionCycle(get_current_cycle(config), config, self.bot.get_guild(config.params.guild_id))
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            self.bot.get_guild(config.params.guild_id),
+        )
         await cycle.election_start_action()
 
     @test.subcommand()
+    @is_me()
     async def voting_start(self, interaction: nextcord.Interaction):
         """
         tests the voting start action
@@ -73,10 +66,15 @@ class TestCog(commands.Cog, name="Test commands."):
             interaction (nextcord.Interaction): _description_
         """
         config: DakinyConfig = self.bot.config
-        cycle = ElectionCycle(get_current_cycle(config), config, self.bot.get_guild(config.params.guild_id))
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            self.bot.get_guild(config.params.guild_id),
+        )
         await cycle.voting_start_action()
 
     @test.subcommand()
+    @is_me()
     async def voting_end(self, interaction: nextcord.Interaction):
         """
         tests the voting start action
@@ -85,17 +83,59 @@ class TestCog(commands.Cog, name="Test commands."):
             interaction (nextcord.Interaction): _description_
         """
         config: DakinyConfig = self.bot.config
-        cycle = ElectionCycle(get_current_cycle(config), config, self.bot.get_guild(config.params.guild_id))
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            self.bot.get_guild(config.params.guild_id),
+        )
         await cycle.voting_end_action()
 
     @test.subcommand()
+    @is_me()
+    async def highcouncil_vote(self, interaction: nextcord.Interaction):
+        """
+        tests the voting start action
+
+        Args:
+            interaction (nextcord.Interaction): _description_
+        """
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            self.bot.get_guild(config.params.guild_id),
+        )
+        await cycle.highcouncil_election_start_action()
+
+    @test.subcommand()
+    @is_me()
     async def election_reminder(self, interaction: nextcord.Interaction):
         config: DakinyConfig = self.bot.config
-        cycle = ElectionCycle(get_current_cycle(config), config, self.bot.get_guild(config.params.guild_id))
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            self.bot.get_guild(config.params.guild_id),
+        )
         await cycle.election_reminder()
 
     @test.subcommand()
+    @is_me()
     async def daily(self, interaction: nextcord.Interaction):
         config: DakinyConfig = self.bot.config
-        cycle = ElectionCycle(get_current_cycle(config), config, self.bot.get_guild(config.params.guild_id))
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            self.bot.get_guild(config.params.guild_id),
+        )
         await cycle.check_date()
+
+    @test.subcommand()
+    @is_me()
+    async def term_start(self, interaction: nextcord.Interaction):
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(
+            get_current_cycle(config),
+            config,
+            self.bot.get_guild(config.params.guild_id),
+        )
+        await cycle.term_start_action()

cogs/commands/view.py

@@ -0,0 +1,96 @@
+"""
+Commands for viewing information in the database.
+"""
+
+import nextcord
+from nextcord.ext import commands
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from database_setup.sql_data_classes import ElectionInformation, Votes, engine
+
+
+class ViewCog(commands.Cog, name="View Commands"):
+    """
+    Holds the view commands.
+    """
+
+    def __init__(self) -> None:
+        """
+        Default constructor for ViewCog class. Does nothing.
+        """
+
+    @nextcord.slash_command()
+    async def view(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for set. Never called.
+        """
+
+    @view.subcommand(
+        description="Shows all voters and who they voted for in a given election."
+    )
+    async def votes(
+        self,
+        interaction: nextcord.Interaction,
+        election_name: str = nextcord.SlashOption(
+            required=True, description="The election you want to view votes for."
+        ),
+    ):
+        """
+        Takes in an election name and sends a response message to the user with a list of people who voted in that
+        election and who they voted for. Notes those tho abstained. Tells a user if the election is invalid. Uses
+        autocompletion to assist with getting elections.
+
+        Args:
+            interaction (nextcord.Interaction): User's interaction with the command.
+            election_name (str): Is SlashOption. The name of the election to view votes for.
+        """
+
+        stmt = select(Votes).where(Votes.ElectionCycle == election_name)
+
+        with Session(engine) as session:
+            # Check if election exists.
+            if session.scalar(stmt) is None:
+                await interaction.response.send_message(
+                    f"Invalid election: {election_name}.", ephemeral=True
+                )
+                return
+
+            votes = session.scalars(stmt)
+            content = ""
+            for vote in votes:
+                content += (
+                    f"<@{vote.VoterId}> voted for <@{vote.VotedForId}>.\n"
+                    if vote.VotedForId is not None
+                    else f"<@{vote.VoterId}> abstained from voted.\n"
+                )
+
+            await interaction.response.send_message(content=content, ephemeral=True)
+
+    @votes.on_autocomplete("election_name")
+    async def election_autocomplete(
+        self, interaction: nextcord.Interaction, election_name: str
+    ):
+        """
+        Collects all elections that start with the election string.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with command.
+            election_name (str): String to run autocomplete on.
+        """
+
+        with Session(engine) as session:
+            stmt = select(ElectionInformation.ElectionCycle)
+            elections = session.scalars(stmt)
+
+            # if empty compare string
+            if not election_name:
+                await interaction.response.send_autocomplete(elections)
+                return
+
+            autofilled_elections: "list[str]" = [
+                election
+                for election in elections
+                if election.lower().startswith(election_name.lower())
+            ]
+            await interaction.response.send_autocomplete(autofilled_elections[:25])

config.py

@@ -10,10 +10,8 @@ class Params:
     Class defines the various configuration parameters.
     """
 
-    active_category_id: int
     admin_channel_id: int  # might want to rename this...
     announcement_category_id: int
-    archive_channel_group_id: int
     clan_council_elect_role_id: int
     clan_council_role_id: int
     clan_info_channel_id: int
@@ -22,6 +20,7 @@ class Params:
     general_channel_id: int
     guild_id: int
     high_council_role_id: int
+    voting_parent_id: int
 
 
 @dataclass

dakiny_bot.py

@@ -8,7 +8,9 @@ from hydra.core.config_store import ConfigStore
 from nextcord.ext import commands
 
 import database_setup.create_database as create_database
+from classes.nominate_highcouncil_views import NominateHighCouncilView
 from classes.nominate_views import NominateView
+from classes.voting_highcouncil_views import VoteHighcouncilView
 from classes.voting_views import VoteView
 from config import DakinyConfig
 
@@ -20,7 +22,9 @@ birthday_list: list[int] = []
 logger = logging.getLogger("nextcord")
 logger.setLevel(logging.DEBUG)
 handler = logging.FileHandler(filename="nextcord.log", encoding="utf-8", mode="w")
-handler.setFormatter(logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s"))
+handler.setFormatter(
+    logging.Formatter("%(asctime)s:%(levelname)s:%(name)s: %(message)s")
+)
 logger.addHandler(handler)
 
 
@@ -51,8 +55,10 @@ def main(cfg: DakinyConfig):
         """When Discord is connected"""
         assert bot.user is not None
         create_database  # pylint: disable=pointless-statement
-        bot.add_view(NominateView(cfg))
+        bot.add_view(NominateView(cfg, bot.get_guild(cfg.params.guild_id)))
+        bot.add_view(NominateHighCouncilView(cfg, bot.get_guild(cfg.params.guild_id)))
         bot.add_view(VoteView(cfg, bot.get_guild(cfg.params.guild_id)))
+        bot.add_view(VoteHighcouncilView(cfg, bot.get_guild(cfg.params.guild_id)))
         print(f"{bot.user.name} has connected to Discord!")
 
     # Run Discord bot

database_setup/database.sql

@@ -1,7 +1,10 @@
 CREATE TABLE ElectionInformation(
     ElectionCycle varchar(30) not null unique,
-    ElectionChannel bigint unsigned not null,
+    ThreadId bigint unsigned not null,
     CouncilVoteMsgId bigint unsigned,
+    HighCouncilVoteMsgId bigint unsigned,
+    CouncilNominationMsgId bigint unsigned,
+    HighCouncilNominationMsgId bigint unsigned,
     PRIMARY KEY (ElectionCycle)
 );
 
@@ -10,9 +13,10 @@ CREATE TABLE CouncilMembers(
     MemberId bigint unsigned not null,
     SpeechMsgId bigint unsigned not null,
     Elected boolean DEFAULT false,
-    HighCouncilElect boolean DEFAULT false,
     DiscordManager boolean DEFAULT false,
     ClanLeader boolean DEFAULT false,
+    DiscordManagerSpeechId bigint unsigned,
+    ClanLeaderSpeechId bigint unsigned,
     FOREIGN KEY (ElectionCycle) REFERENCES ElectionInformation(ElectionCycle),
     PRIMARY KEY (ElectionCycle, MemberId)
 );

utils.py

@@ -10,6 +10,8 @@ from sqlalchemy.orm import Session
 from config import DakinyConfig
 from database_setup.sql_data_classes import CouncilMembers, Votes, engine
 
+NOMINEE_SPLITTER = "========================================\n\n"
+
 
 def get_datetime(day: str) -> datetime:
     """
@@ -36,13 +38,46 @@ def get_election_cycle_name(config: DakinyConfig) -> str:
     """
     Builds the unique name of the current election cycle
 
+    Args:
+        config (DakinyConfig): the config used to know the election cycle.
+
     Returns:
         str: the name of the election cycle
     """
     cycle = get_current_cycle(config)
     current_cycle = config.election_cycles[cycle]
 
-    return f"vote-{get_datetime(current_cycle.election_start).year}-{current_cycle.name}"
+    return (
+        f"vote-{get_datetime(current_cycle.election_start).year}-{current_cycle.name}"
+    )
+
+
+def get_dm_election_name(config: DakinyConfig) -> str:
+    """
+    creates the name of the discord manager election
+
+    Args:
+        config (DakinyConfig): Config sent to get_election_cycle_name
+
+    Returns:
+        str: the name of the election
+    """
+
+    return f"{get_election_cycle_name(config)}-dm"
+
+
+def get_cl_election_name(config: DakinyConfig) -> str:
+    """
+    creates the name of the clan leader election
+
+    Args:
+        config (DakinyConfig): Config sent to get_election_cycle_name
+
+    Returns:
+        str: the name of the election
+    """
+
+    return f"{get_election_cycle_name(config)}-cl"
 
 
 def get_current_cycle(config: DakinyConfig) -> int:
@@ -82,22 +117,148 @@ def build_votes_str(config: DakinyConfig) -> str:
     votes: dict[int, int] = {}
 
     with Session(engine) as session:
-        stmt = select(CouncilMembers).where(CouncilMembers.ElectionCycle == get_election_cycle_name(config))
+        stmt = select(CouncilMembers).where(
+            CouncilMembers.ElectionCycle == get_election_cycle_name(config)
+        )
 
         for nominee in session.scalars(stmt):
             votes[nominee.MemberId] = 0
 
-        stmt = select(Votes).where(Votes.ElectionCycle == get_election_cycle_name(config))
+        stmt = select(Votes).where(
+            Votes.ElectionCycle == get_election_cycle_name(config)
+        )
 
         for vote in session.scalars(stmt):
             if vote.VotedForId is not None:
                 votes[vote.VotedForId] += 1
 
     votes_str: str = "===================="
-    for user_id, num_votes in votes.items():
+    votes_str += user_vote_str(votes)
-        votes_str += f"\n<@{user_id}>: "
-
-        for num in range(num_votes):
-            votes_str += "☑️"
 
     return votes_str
+
+
+def build_highcouncil_votes_str(config: DakinyConfig) -> str:
+    """
+    Creates a string that contains all high council nominees and their votes to be sent as a discord message.
+
+    Args:
+        config (DakinyConfig): Daking config object
+
+    Returns:
+        str: String that contains all nominees and their votes.
+    """
+
+    cl_votes: dict[int, int] = {}
+    dm_votes: dict[int, int] = {}
+
+    with Session(engine) as session:
+        stmt = (
+            select(CouncilMembers)
+            .where(CouncilMembers.ElectionCycle == get_election_cycle_name(config))
+            .filter(CouncilMembers.ClanLeaderSpeechId.is_not(None))
+        )
+
+        for nominee in session.scalars(stmt):
+            cl_votes[nominee.MemberId] = 0
+
+        stmt = select(Votes).where(Votes.ElectionCycle == get_cl_election_name(config))
+
+        for vote in session.scalars(stmt):
+            if vote.VotedForId is not None:
+                cl_votes[vote.VotedForId] += 1
+
+        stmt = (
+            select(CouncilMembers)
+            .where(CouncilMembers.ElectionCycle == get_election_cycle_name(config))
+            .filter(CouncilMembers.DiscordManagerSpeechId.is_not(None))
+        )
+
+        for nominee in session.scalars(stmt):
+            dm_votes[nominee.MemberId] = 0
+
+        stmt = select(Votes).where(Votes.ElectionCycle == get_dm_election_name(config))
+
+        for vote in session.scalars(stmt):
+            if vote.VotedForId is not None:
+                dm_votes[vote.VotedForId] += 1
+
+    # build the votes string
+    votes_str: str = "Clan Leader Votes\n===================="
+    votes_str += user_vote_str(cl_votes)
+
+    votes_str += "\n\nDiscord Manager Votes\n===================="
+    votes_str += user_vote_str(dm_votes)
+
+    return votes_str
+
+
+def user_vote_str(votes: dict[int, int]) -> str:
+    """
+    Creates the string representing how many votes each user has.
+
+    Args:
+        votes (dict[int, int]): Dict of all users and how many votes they have.
+
+    Returns:
+        str: The string showing names and number of votes.
+    """
+    ret_str: str = ""
+
+    for user_id, num_votes in votes.items():
+        ret_str += f"\n<@{user_id}>: {'☑️' * num_votes}"
+    return ret_str
+
+
+def decorate_nomination(user_id: int, speech: str) -> str:
+    """
+    Decorates a nomination speech so that it sits within multiple speeches better.
+
+    Args:
+        user_id (int): ID of user sending the speech
+        speech (str): Speech from the user
+
+    Returns:
+        str: Decorated speech
+    """
+    msg = f"**Clan Council Nominee: <@{user_id}>**\n"
+    msg += NOMINEE_SPLITTER
+    msg += speech
+
+    return msg
+
+
+def decorate_cl_nomination(user_id: int, speech: str) -> str:
+    """
+    Decorates a nomination speech so that it sits within multiple speeches better.
+
+    Args:
+        user_id (int): ID of user sending the speech
+        speech (str): Speech from the user
+
+    Returns:
+        str: Decorated speech
+    """
+    msg = f"**Clan Leader Nominee: <@{user_id}>**\n"
+    msg += NOMINEE_SPLITTER
+    msg += speech
+
+    return msg
+
+
+def decorate_dm_nomination(user_id: int, speech: str) -> str:
+    """
+    Decorates a nomination speech so that it sits within multiple speeches better.
+
+    Args:
+        user_id (int): ID of user sending the speech
+        speech (str): Speech from the user
+
+    Returns:
+        str: Decorated speech
+    """
+    msg = f"**Discord Manager Nominee: <@{user_id}>**\n"
+    msg += NOMINEE_SPLITTER
+    msg += speech
+
+    return msg