Correct date being used for getting the election cycle name.

Remove guild ids.

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.
-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.
+Each member of the CCE can vote once in each category (Discord Server Manager and Clan Leader). Alternatively, you may choose to intentionally abstain.
 
 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,10 +6,12 @@ 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 (
@@ -18,7 +20,14 @@ from database_setup.sql_data_classes import (
     Votes,
     engine,
 )
-from utils import build_votes_str, get_datetime, get_election_cycle_name
+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:
@@ -192,16 +201,9 @@ class ElectionCycle:
 
         thread_msg: nextcord.Message = await parent.send(content=quarter_name)
 
-        # create new entry into database.
         thread: nextcord.Thread = await parent.create_thread(
             name=quarter_name, message=thread_msg
         )
-        with Session(engine) as session:
-            new_cycle = ElectionInformation(
-                ElectionCycle=quarter_name, ThreadId=thread.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
@@ -210,10 +212,22 @@ class ElectionCycle:
         for index, message in enumerate(messages):
             # if last item, add the nominate button
             if index + 1 == len(messages):
-                await thread.send(message, view=NominateView(self.config))
+                nominate_msg: nextcord.Message = await thread.send(
+                    message, view=NominateView(self.config, self.guild)
+                )
             else:
                 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:
         """
         Sends message informing members that voting has started.
@@ -237,6 +251,12 @@ class ElectionCycle:
             info.CouncilVoteMsgId = vote_msg.id
             session.commit()
 
+            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:
         """
         Performs required actions for when voting time has ended.
@@ -250,18 +270,28 @@ class ElectionCycle:
             self.get_election_info().ThreadId
         )
 
-        # remove vote button from vote message
+        nominate_msg: nextcord.Message = await election_thread.send(
+            message, view=NominateHighCouncilView(self.config, self.guild)
+        )
+
         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)
-        vote_msg: nextcord.Message = await election_thread.fetch_message(vote_msg_id)
+            info = session.scalar(stmt)
+            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))
 
@@ -276,11 +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 election_thread.send(message)
+                    await member.add_roles(
+                        council_elect_role,
+                        reason=f"{member.display_name} has won a nomination and become a Council Elect.",
+                    )
 
     async def highcouncil_election_start_action(self) -> None:
         """
@@ -292,6 +323,25 @@ class ElectionCycle:
             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:
         """
@@ -300,10 +350,68 @@ class ElectionCycle:
 
         self.election_over = True
 
+        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!"
         )

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
-
-NOMINEE_SPLITTER = "========================================\n\n"
+from utils import NOMINEE_SPLITTER, decorate_nomination, get_election_cycle_name
 
 
 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
@@ -70,8 +74,12 @@ class NominateModal(nextcord.ui.Modal):
                 )
                 obj = session.scalar(stmt)
 
-                msg: nextcord.Message = await interaction.channel.fetch_message(obj.SpeechMsgId)
-                await msg.edit(content=decorate_nomination(interaction.user.id, self.speech.value))
+                msg: nextcord.Message = await interaction.channel.fetch_message(
+                    obj.SpeechMsgId
+                )
+                await msg.edit(
+                    content=decorate_nomination(interaction.user.id, self.speech.value)
+                )
 
 
 class NominateView(nextcord.ui.View):
@@ -79,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")
-    async def nominate(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:
+    @nextcord.ui.button(
+        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.
@@ -94,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 = ""
@@ -110,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: 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

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

@@ -130,9 +130,9 @@ class VoteView(nextcord.ui.View):
 
             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)

cogs/commands/__init__.py

@@ -4,6 +4,7 @@ Cog loader. Adds all command cogs to the bot.
 
 from nextcord.ext import commands
 
+from cogs.commands.remove import RemoveCog
 from cogs.commands.request import RequestCog
 from cogs.commands.set import setCog
 from cogs.commands.test import TestCog
@@ -17,7 +18,8 @@ def setup(bot: commands.Bot):
     Adds all command classes to bot.
     """
 
+    bot.add_cog(RemoveCog())
     bot.add_cog(RequestCog(bot))
     bot.add_cog(TestCog(bot))
-    bot.add_cog(setCog())
     bot.add_cog(ViewCog())
+    bot.add_cog(setCog())

cogs/commands/remove.py

@@ -0,0 +1,86 @@
+"""
+Commands for removing information in the database.
+"""
+
+import nextcord
+from nextcord.ext import commands
+from sqlalchemy import delete, select
+from sqlalchemy.orm import Session
+
+from database_setup.sql_data_classes import Presences, engine
+
+
+class RemoveCog(commands.Cog, name="Remove Commands"):
+    """
+    Holds the view commands.
+    """
+
+    def __init__(self) -> None:
+        """
+        Default constructor for RemoveCog class. Does nothing.
+        """
+
+    @nextcord.slash_command(
+        default_member_permissions=nextcord.Permissions(administrator=True),
+    )
+    async def remove(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for set. Never called.
+        """
+
+    @remove.subcommand(description="Remove a presence from the database.")
+    async def presence(
+        self,
+        interaction: nextcord.Interaction,
+        presence_str: str = nextcord.SlashOption(
+            description="The presence to remove", required=True
+        ),
+    ):
+        """
+        Deletes the given presence id from the database.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            presence (str): Is SlashOption. The presence to remove. Is the ID of the presence.
+        """
+
+        presence_id = int(presence_str)
+        with Session(engine) as session:
+            stmt = delete(Presences).where(Presences.Id == presence_id)
+            session.execute(stmt)
+            session.commit()
+
+        await interaction.response.send_message("Presence deleted.", ephemeral=True)
+
+    @presence.on_autocomplete("presence_str")
+    async def presence_autocomplete(
+        self, interaction: nextcord.Interaction, presence_str: str
+    ):
+        """
+        Collects all presences that start with the presence string.
+        Sends autocomplete dict {Presence Name, Presence Id}
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with command.
+            presence_str (str): String to run autocomplete on.
+        """
+
+        with Session(engine) as session:
+            stmt = select(Presences)
+            presences_dict: "dict[str,str]" = {
+                pres.Presence: str(pres.Id) for pres in session.scalars(stmt)
+            }
+
+            # if empty compare string
+            if not presence_str:
+                await interaction.response.send_autocomplete(
+                    dict(list(presences_dict.items())[:25])
+                )
+                return
+
+            autofilled_presences: "dict[str,str]" = {
+                pres: pres_id
+                for pres, pres_id in presences_dict.items()
+                if presence_str.lower() in pres.lower()
+            }
+            await interaction.response.send_autocomplete(autofilled_presences[:25])

cogs/commands/request.py

@@ -4,8 +4,10 @@ Contains commands and views for request commands.
 
 import nextcord
 from nextcord.ext import commands
+from sqlalchemy.orm import Session
 
 from config import DakinyConfig
+from database_setup.sql_data_classes import Presences, engine
 
 
 class RequestCog(commands.Cog, name="Request Commands"):
@@ -25,12 +27,46 @@ class RequestCog(commands.Cog, name="Request Commands"):
         Parent slash command for help. Never called.
         """
 
+    @request.subcommand(
+        description="Request to add a presence to the bot's presence list."
+    )
+    async def add_presence(
+        self,
+        interaction: nextcord.Interaction,
+        presence: str = nextcord.SlashOption(
+            required=True,
+            min_length=1,
+            max_length=100,
+            description="The presence you want to add.",
+        ),
+    ):
+        """
+        Sends a message to admins to request to add a presence.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            presence (str): The presence to add.
+        """
+
+        config: DakinyConfig = self.bot.config
+        content = f'<@{interaction.user.id}> would like to add presence "{presence}."'
+        view = PresenceChange(presence)
+        await self.bot.get_channel(config.params.admin_channel_id).send(
+            content=content, view=view
+        )
+        await interaction.response.send_message(
+            "Request sent to admins.", ephemeral=True
+        )
+
     @request.subcommand(description="Request to change your Dakiny nickname")
     async def change_nickname(
         self,
         interaction: nextcord.Interaction,
         new_nickname: str = nextcord.SlashOption(
-            required=True, min_length=2, max_length=32, description="Your requested new nickname."
+            required=True,
+            min_length=2,
+            max_length=32,
+            description="Your requested new nickname.",
         ),
     ):
         """
@@ -44,8 +80,12 @@ class RequestCog(commands.Cog, name="Request Commands"):
         config: DakinyConfig = self.bot.config
         content = f'<@{interaction.user.id}> would like to change their username to "{new_nickname}."'
         view = UsernameRequest(interaction.user.id, new_nickname)
-        await self.bot.get_channel(config.params.admin_channel_id).send(content=content, view=view)
-        await interaction.response.send_message("Request sent to admins.", ephemeral=True)
+        await self.bot.get_channel(config.params.admin_channel_id).send(
+            content=content, view=view
+        )
+        await interaction.response.send_message(
+            "Request sent to admins.", ephemeral=True
+        )
 
 
 class UsernameRequest(nextcord.ui.View):
@@ -53,13 +93,19 @@ class UsernameRequest(nextcord.ui.View):
     View provides approve and deny buttons and action for a username change request.
     """
 
-    def __init__(self, user_id: int, new_nickname: str, *, timeout: float | None = 180, auto_defer: bool = True):
-        super().__init__(timeout=timeout, auto_defer=auto_defer)
+    def __init__(
+        self,
+        user_id: int,
+        new_nickname: str,
+    ):
+        super().__init__(timeout=None, auto_defer=True)
         self.user_id = user_id
         self.new_nickname = new_nickname
 
     @nextcord.ui.button(label="Approve", style=nextcord.ButtonStyle.green)
-    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
+    async def approve(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):
         """
         Approve button for a nickname change request. Changes the target's nickname to self.new_nickname.
         Catches an error if the target as a higher role than the bot.
@@ -73,7 +119,10 @@ class UsernameRequest(nextcord.ui.View):
         if user is not None:
             try:
                 await user.edit(nick=self.new_nickname)
-                content = interaction.message.content + f"\nApproved by <@{interaction.user.id}>."
+                content = (
+                    interaction.message.content
+                    + f"\nApproved by <@{interaction.user.id}>."
+                )
                 await interaction.response.edit_message(content=content, view=None)
             except nextcord.errors.Forbidden:
                 await interaction.response.send_message(
@@ -84,10 +133,13 @@ class UsernameRequest(nextcord.ui.View):
                     interaction.message.content
                     + "\n\nFailed. User has too high permissions for bot to change nickname."
                 )
-                await interaction.followup.edit_message(interaction.message.id, content=content, view=None)
+                await interaction.followup.edit_message(
+                    interaction.message.id, content=content, view=None
+                )
         else:
             await interaction.response.edit_message(
-                content="An error occured while changing the user's nickname.", view=None
+                content="An error occured while changing the user's nickname.",
+                view=None,
             )
 
     @nextcord.ui.button(label="Deny", style=nextcord.ButtonStyle.red)
@@ -101,3 +153,50 @@ class UsernameRequest(nextcord.ui.View):
         """
         content = interaction.message.content + f"\nDenied by <@{interaction.user.id}>."
         await interaction.response.edit_message(content=content, view=None)
+
+
+class PresenceChange(nextcord.ui.View):
+    """
+    View provides approve and deny buttons and action for a username change request.
+    """
+
+    def __init__(
+        self,
+        presence: str,
+    ):
+        super().__init__(timeout=None, auto_defer=True)
+        self.presence = presence
+
+    @nextcord.ui.button(label="Approve", style=nextcord.ButtonStyle.green)
+    async def approve(
+        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
+    ):
+        """
+        Approve button for a presence add request. Adds the presence to the database.
+        Removes the view from the interaction message.
+
+        Args:
+            button (nextcord.ui.Button): Unused.
+            interaction (nextcord.Interaction): The interaction of the user clicking the button.
+        """
+
+        with Session(engine) as session:
+            session.add(Presences(Presence=self.presence))
+            session.commit()
+
+        content = (
+            interaction.message.content + f"\nApproved by <@{interaction.user.id}>."
+        )
+        await interaction.response.edit_message(content=content, view=None)
+
+    @nextcord.ui.button(label="Deny", style=nextcord.ButtonStyle.red)
+    async def deny(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
+        """
+        Deny button for a presence add request. Just removes the view and logs who denied the request.
+
+        Args:
+            button (nextcord.ui.Button): Unused.
+            interaction (nextcord.Interaction): The interaction of the user clicking the button.
+        """
+        content = interaction.message.content + f"\nDenied by <@{interaction.user.id}>."
+        await interaction.response.edit_message(content=content, view=None)

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,12 @@ class TestCog(commands.Cog, name="Test commands."):
         """
         self.bot = bot
 
-    def is_me():
-        def predicate(interaction: nextcord.Interaction):
-            return interaction.user.id == 206602713511886849
-
-        return application_checks.check(predicate)
-
-    @nextcord.slash_command()
-    @is_me()
+    @nextcord.slash_command(guild_ids=[1000247361639030804])
     async def test(self, interaction: nextcord.Interaction):
         """
         Parent slash command for help. Never called.
         """
 
-    @test.subcommand()
-    @is_me()
-    async def msg_builder(self, interaction: nextcord.Interaction):
-        """
-        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()
     @is_me()
     async def election_start(self, interaction: nextcord.Interaction):
@@ -104,6 +90,23 @@ class TestCog(commands.Cog, name="Test commands."):
         )
         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):

cogs/commands/view.py

@@ -7,7 +7,12 @@ from nextcord.ext import commands
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
-from database_setup.sql_data_classes import ElectionInformation, Votes, engine
+from database_setup.sql_data_classes import (
+    ElectionInformation,
+    Presences,
+    Votes,
+    engine,
+)
 
 
 class ViewCog(commands.Cog, name="View Commands"):
@@ -26,6 +31,42 @@ class ViewCog(commands.Cog, name="View Commands"):
         Parent slash command for set. Never called.
         """
 
+    @view.subcommand(description="Show all possible presence choices.")
+    async def presences(
+        self,
+        interaction: nextcord.Interaction,
+        search: str = nextcord.SlashOption(
+            description="A word or string to search for in the presences.",
+            required=False,
+        ),
+    ):
+        """
+        Gathers all presences from the database and responds with a message showing them.
+
+        Args:
+            interaction (nextcord.Integration):  User's interaction with the command.
+        """
+
+        # might take a while depending on number of presences
+        await interaction.response.defer(ephemeral=True)
+
+        with Session(engine) as session:
+            stmt = select(Presences.Presence)
+            presences = session.scalars(stmt)
+
+            if search:
+                message = "\n".join(
+                    [
+                        presence
+                        for presence in presences
+                        if search.lower() in presence.lower()
+                    ]
+                )
+            else:
+                message = "\n".join(list(presences))
+
+        await interaction.followup.send(content=message, ephemeral=True)
+
     @view.subcommand(
         description="Shows all voters and who they voted for in a given election."
     )
@@ -85,7 +126,7 @@ class ViewCog(commands.Cog, name="View Commands"):
 
             # if empty compare string
             if not election_name:
-                await interaction.response.send_autocomplete(elections)
+                await interaction.response.send_autocomplete(list(elections)[:25])
                 return
 
             autofilled_elections: "list[str]" = [

cogs/loops/__init__.py

@@ -4,7 +4,8 @@ Initializing code for all loops.
 
 from nextcord.ext import commands
 
-from .daily_loop import DailyLoop
+from cogs.loops.bot_presence import BotPresence
+from cogs.loops.daily_loop import DailyLoop
 
 
 def setup(bot: commands.Bot):
@@ -12,4 +13,5 @@ def setup(bot: commands.Bot):
     Adds functions to bot.
     """
 
+    bot.add_cog(BotPresence(bot))
     bot.add_cog(DailyLoop(bot))

cogs/loops/bot_presence.py

@@ -0,0 +1,48 @@
+"""
+Functions for controlling the bot's presence. Also contains the loop.
+"""
+
+import nextcord
+from nextcord.ext import commands, tasks
+from sqlalchemy import func, select
+from sqlalchemy.orm import Session
+
+from database_setup.sql_data_classes import Presences, engine
+
+
+class BotPresence(commands.Cog, name="Bot Presence"):
+    """Class for bot presence functions."""
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_guild_join(
+        self, guild: nextcord.Guild
+    ):  # pylint: disable=unused-argument
+        """Listener for Guild Join. Updated presence on guild join."""
+        await self.change_presence()
+
+    @commands.Cog.listener()
+    async def on_ready(self):
+        """Starts the loop when bot is ready."""
+        await self.bot.wait_until_ready()
+        # pylint doesn't recognize that periodic_change_presense is subclassed from tasks.loop.
+        self.periodic_change_presence.start()  # pylint: disable=no-member
+
+    @tasks.loop(minutes=5)
+    async def periodic_change_presence(self):
+        """Loops every 5 minutes and changes presence."""
+        await self.change_presence()
+
+    async def change_presence(self):
+        """Randomly chooses a presence and updates bot's presence."""
+
+        with Session(engine) as session:
+            presence = session.scalar(
+                select(Presences.Presence).order_by(func.random())
+            )
+
+        await self.bot.change_presence(
+            activity=nextcord.CustomActivity(name="Custom Status", state=presence)
+        )

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

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

@@ -2,6 +2,9 @@ CREATE TABLE ElectionInformation(
     ElectionCycle varchar(30) not null unique,
     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)
 );
@@ -30,3 +34,8 @@ CREATE TABLE UserBirthday (
     Birthday varchar(5) not null,
     PRIMARY KEY (UserId)
 );
+
+CREATE TABLE Presences (
+    Id integer PRIMARY KEY,
+    Presence varchar(100) not null
+);

database_setup/sql_data_classes.py

@@ -15,3 +15,4 @@ ElectionInformation = Base.classes.ElectionInformation
 CouncilMembers = Base.classes.CouncilMembers
 Votes = Base.classes.Votes
 UserBirthday = Base.classes.UserBirthday
+Presences = Base.classes.Presences

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:
     """
@@ -26,7 +28,7 @@ def get_datetime(day: str) -> datetime:
     day = int(day.split("/")[1])
 
     # ensure that year rolls over if current month is December and the next month is less than 12.
-    if datetime.today().month == 12 & month < 12:
+    if datetime.today().month == 12 and month < 12:
         year += 1
 
     return datetime(year, month, day)
@@ -36,13 +38,44 @@ 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.term_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 +115,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 += f"\n<@{user_id}>: "
-
-        for num in range(num_votes):
-            votes_str += "☑️"
+    votes_str += user_vote_str(votes)
 
     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