Merge branch 'main' into mock-election

.gitignore

@@ -105,7 +105,6 @@ venv/
 ENV/
 env.bak/
 venv.bak/
-poetry.lock
 
 # Spyder project settings
 .spyderproject
@@ -131,7 +130,7 @@ dmypy.json
 # logging
 nextcord.log
 
-# bot files
+# data file for bot
 highscores_data.json
 highscores_config.json
 deleted_backups/
@@ -141,4 +140,3 @@ sql_tester.py
 conf
 outputs
 database
-dakiny-messages/

Dockerfile

@@ -1,19 +1,26 @@
-FROM python:3.11.9-slim
+FROM python:3.10.6-slim
 
-# install dependencies
-RUN apt-get update && apt-get -y upgrade && apt-get -y install git
+# install dependencies for mysqlclient
+# RUN apt-get update && apt-get -y upgrade && apt-get -y install python3-dev default-libmysqlclient-dev build-essential
+
+RUN pip install --upgrade pip
 
 WORKDIR /home
 
-COPY config.py config.py
-COPY main.py main.py
-COPY utils.py utils.py
-COPY pyproject.toml pyproject.toml
+COPY requirements.txt requirements.txt
 
+COPY config.py config.py
+COPY dakiny_bot.py dakiny_bot.py
+COPY utils.py utils.py
+
+COPY bot_messages bot_messages/
 COPY classes classes/
 COPY cogs cogs/
 COPY database_setup database_setup/
 
-RUN pip install --upgrade pip && pip install poetry && poetry export -f requirements.txt --output requirements.txt && pip install -r requirements.txt
+RUN pip install -r requirements.txt
 
-CMD ["python3", "-u", "./main.py"]
+# remove build deps that aren't needed to run
+# RUN apt-get -y remove python3-dev build-essential && apt-get -y autoremove
+
+CMD ["python3", "-u", "./dakiny_bot.py"]

README.md

@@ -1,9 +1,5 @@
 # Dakiny Bot
 
-Dakiny clan's own discord bot!
-
-
-### Assumptions
-- For Elections: Bot assumes that it always did the step before it. If the step before an action didn't happen, behavior is undefined.
+Bot assumes that it always did the step before it. If the step before an action didn't happen, behavior is undefined.
 Object creation in the middle of a cycle is only there for restarting the bot. All relevant information should already
 exist in the database.

bot_messages/council_members.txt

@@ -0,0 +1,7 @@
+Here's the {quarter} Clan Council:
+
+Dakiny Council: 
+{council}
+
+Dakiny High Council:
+{high_council}

bot_messages/election_announcement.txt

@@ -0,0 +1,54 @@
+```fix
+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.
+
+This clan is about human interaction, and the Clan Council positions serve to prop up certain voices within our community, in an effort to shape it as a force for good. Our mission here is to spread love. The more loving Council Members (CMs) we have on the team, the greater the community will grow for all of us to enjoy. There are no term limits, but if you go inactive on RS or become uninterested in pouring your effort into this community, request to step down so that others may contribute where you are no longer able to.
+
+We want all CMs to grow and succeed. Please, reach out for assistance and advice if you find yourself going even a few days without taking real, actionable steps towards the prosperity of Dakiny. Recruiting, hosting events, participating in the Clan Council Discord, and demonstrating the Core Elements of the position are required from each and every CM to grow a happy and healthy clan.
+
+__So here's how it works:__
+---message_break---
+Each quarter, a channel is created here on Discord for clan members to cast their vote to determine the Clan Council for that 3-month period. 
+
+**Only clan members can vote and all clan members are granted exactly one equally weighted vote.** If you vote twice for different people, your vote will be annulled. 
+
+All clan members are permitted to run for a seat on the Clan Council as long as they:
+
+**i)** have been in the clan for at least 13 weeks (enough time to have participated in at least one election);
+
+**ii)** have no warnings under their name in the last 6 months and
+
+**iii)** have been active in the clan for the past 13 weeks prior to the first day of elections. To be considered active in that timeframe, one must fulfill the following criteria: hosted/participated in at least three clan events, each one in a different week;
+
+**iv)** are not running under aliases that hide their true identity.
+
+Candidates are permitted to vote for themselves. Once a candidate reaches 3 votes from clan members, they have earned their seat, meaning no more votes can be cast for them.
+
+Then, the new Clan Council Elect will come together to select the 2 High Council positions:
+RuneScape 3 Clan Leader
+Discord Server Manager
+
+The Clan Council will be denoted by the Discord ranks of <@&{clan_council_id}> and <@&{high_council_id}> and in-game with the following ranks.
+<:Rank_Admin:479008185240518656> Admin
+<:Rank_Organiser:479008215024009216> Organizer
+<:Rank_Coordinator:479008238654849045> Coordinator
+<:Rank_Overseer:479008269382451201> Overseer
+<:Rank_Deputy:479008295319896064> Deputy Owner
+<:Rank_Owner:479008325137072155> Clan Leader
+---message_break---
+__Here's the timeline:__
+Election begins: {election_start}
+Term: {term_start} - {term_end}
+
+**{election_start}**: Post here to announce candidacy
+**{voting_start}**: Voting begins
+**{voting_end}**: Votes are tallied and winners are announced
+**{highcouncil_election}**: The new Clan Council votes who among them shall receive the two High Council positions of: Clan Leader and Discord Server Manager.
+**{term_start}**: The new Clan Council is officially inaugurated and a drop party (or a giveaway event) begins to commemorate the new leadership.
+
+This process will begin again next quarter on {next_election_start} with the inauguration scheduled for {term_end}.
+---message_break---
+**You may now announce your candidacy for a seat on the Dakiny Clan Council!
+**
+You may include a speech with your announcement, as well as specific pertinent facts such as total recruits, time in the clan, past Clan Council experience, and donations made. This data is available upon request via <@&{clan_council_id}>.

bot_messages/highcouncil_election.txt

@@ -0,0 +1,13 @@
+`Leadership Elections - candidacy time`
+
+
+<@&{clan_council_elect_role_id}>, welcome. We are starting the second part of our elections.  On {highcouncil_election_announce} this channel will be open to write for all of you. Everyone else will be able to read this channel, but not write in it. Only members of the  Clan Council Elected (CCE) can vote now. Any votes from others will be annulled.
+
+From {highcouncil_election_announce} to {highcouncil_election_start}, you will be able to announce your candidacy for High Council. The positions are:
+ 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.
+
+Votes can be cast until {highcouncil_election_end}, so we can announce and have everyone set up to start the term by {term_start}.

bot_messages/highcouncil_vote.txt

@@ -0,0 +1 @@
+<@&{clan_council_elect_role_id}> it is now time to vote for the high council! You have until {term_start} to complete the vote.

bot_messages/vote_start.txt

@@ -0,0 +1,14 @@
+====================
+<@&{clan_member_id}>, it's time to vote for clan council.
+
+Press the Vote button to vote!
+Voting ends next {voting_end_day}, {voting_end}.
+Results will then be announced.
+
+After a candidate receives 3 votes, their spot is secured in the new council, but you can still vote for them to show your support.
+
+**Just a reminder:** only the people listed below are eligible to vote, and each clan member may **only vote for one person**. Votes from guests, diplomats, or allies will be annulled.
+Votes for multiple candidates from the same person will not be counted. 
+
+RS3 Clan Members
+OSRS Clan Members

classes/election_cycle.py

@@ -6,30 +6,14 @@ import collections
 from datetime import datetime, timedelta
 
 import nextcord
-from sqlalchemy import select, true, update
+from sqlalchemy import select
 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 utils import (
-    TEMPLATES_DIR,
-    build_highcouncil_votes_str,
-    build_votes_str,
-    edit_clan_council_info,
-    get_cl_election_name,
-    get_datetime,
-    get_dm_election_name,
-    get_election_name,
-)
+from database_setup.sql_data_classes import CouncilMembers, ElectionInformation, Votes, engine
+from utils import build_votes_str, get_datetime, get_election_cycle_name
 
 
 class ElectionCycle:
@@ -56,15 +40,9 @@ 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_start: datetime = get_datetime(
-            self.election_cycle.highcouncil_election_start
-        )
-        self.highcouncil_election_end: datetime = get_datetime(
-            self.election_cycle.highcouncil_election_end
-        )
+        self.highcouncil_election_announce: datetime = get_datetime(self.election_cycle.highcouncil_election_announce)
+        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
 
@@ -77,15 +55,11 @@ class ElectionCycle:
             long.
         """
 
-        with open(
-            f"{TEMPLATES_DIR}/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(
@@ -110,22 +84,14 @@ class ElectionCycle:
             str: Message to send.
         """
 
-        with open(
-            f"{TEMPLATES_DIR}/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_start=self.highcouncil_election_start.strftime(
-                    "%B %d"
-                ),
-                highcouncil_election_end=self.highcouncil_election_end.strftime(
-                    "%B %d"
-                ),
+                highcouncil_election_announce=self.highcouncil_election_announce.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"),
             )
 
@@ -137,9 +103,7 @@ class ElectionCycle:
             str: Message to send.
         """
 
-        with open(
-            f"{TEMPLATES_DIR}/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(
@@ -155,11 +119,9 @@ class ElectionCycle:
             str: Message to send
         """
 
-        with open(f"{TEMPLATES_DIR}/vote_start.txt", mode="r", encoding="utf8") as file:
+        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,
@@ -178,11 +140,7 @@ 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()
@@ -196,16 +154,17 @@ class ElectionCycle:
         Performs required actions for when the election cycle starts.
         """
         # create new channel for election
-        parent: nextcord.TextChannel = self.guild.get_channel(
-            self.config.params.voting_parent_id
-        )
-        quarter_name: str = get_election_name(self.config)
+        category: nextcord.CategoryChannel = self.guild.get_channel(self.config.params.active_category_id)
+        quarter_name: str = get_election_cycle_name(self.config)
 
-        thread_msg: nextcord.Message = await parent.send(content=quarter_name)
-
-        thread: nextcord.Thread = await parent.create_thread(
-            name=quarter_name, message=thread_msg
-        )
+        # create new entry into database.
+        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)
+        await election_channel.set_permissions(clan_member_role, add_reactions=True)
+        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
@@ -214,21 +173,9 @@ class ElectionCycle:
         for index, message in enumerate(messages):
             # if last item, add the nominate button
             if index + 1 == len(messages):
-                nominate_msg: nextcord.Message = await thread.send(
-                    message, view=NominateView(self.config, self.guild)
-                )
+                await election_channel.send(message, view=NominateView(self.config))
             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()
+                await election_channel.send(message)
 
     async def voting_start_action(self) -> None:
         """
@@ -236,28 +183,20 @@ class ElectionCycle:
         Removes write permission from the general clan member role.
         """
         message = self.build_vote_start()
-        election_thread: nextcord.Thread = self.guild.get_thread(
-            self.get_election_info().ThreadId
-        )
-        await election_thread.send(message)
-        vote_msg = await election_thread.send(
-            build_votes_str(self.config, self.guild),
-            view=VoteView(self.config, self.guild),
-        )
+        clan_member_role: nextcord.Role = self.guild.get_role(self.config.params.clan_member_role_id)
+        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+        await election_channel.send(message)
+        vote_msg = await election_channel.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_name(self.config)
+                ElectionInformation.ElectionCycle == get_election_cycle_name(self.config)
             )
             info = session.scalar(stmt)
             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)
+        await election_channel.set_permissions(clan_member_role, send_messages=False)
 
     async def voting_end_action(self) -> None:
         """
@@ -265,40 +204,27 @@ 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
-        )
-        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)
-        )
-
-        election_name = get_election_name(self.config)
+        council_elect_role: nextcord.Role = self.guild.get_role(self.config.params.clan_council_elect_role_id)
+        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+        clan_member_role: nextcord.Role = self.guild.get_role(self.config.params.clan_member_role_id)
 
+        # remove vote button from vote message
+        election_name = get_election_cycle_name(self.config)
         with Session(engine) as session:
-            # remove vote button from vote message
-            stmt = select(ElectionInformation).where(
+            stmt = select(ElectionInformation.CouncilVoteMsgId).where(
                 ElectionInformation.ElectionCycle == election_name
             )
-            info = session.scalar(stmt)
-            vote_msg: nextcord.Message = await election_thread.fetch_message(
-                info.CouncilVoteMsgId
-            )
-            await vote_msg.edit(view=None)
+            vote_msg_id = session.scalar(stmt)
+        vote_msg: nextcord.Message = await election_channel.fetch_message(vote_msg_id)
+        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
+        # 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))
 
             for user_id, votes in vote_count.items():
-                if votes >= 3:
+                if votes >= 2:
                     stmt = (
                         select(CouncilMembers)
                         .where(CouncilMembers.ElectionCycle == election_name)
@@ -308,12 +234,13 @@ class ElectionCycle:
                     council_member.Elected = True
                     session.commit()
 
-                    member: nextcord.Member = self.guild.get_member(user_id)
+                    user: nextcord.Member = self.guild.get_member(user_id)
 
-                    await member.add_roles(
-                        council_elect_role,
-                        reason=f"{member.display_name} has won a nomination and become a Council Elect.",
-                    )
+                    await user.add_roles(council_elect_role)
+
+        await election_channel.send(message)
+        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:
         """
@@ -321,121 +248,19 @@ class ElectionCycle:
         """
 
         message = self.build_highcouncil_vote_start()
-        election_thread: nextcord.Thread = self.guild.get_thread(
-            self.get_election_info().ThreadId
-        )
-        await election_thread.send(message)
-        vote_msg = await election_thread.send(
-            build_highcouncil_votes_str(self.config, self.guild),
-            view=VoteHighcouncilView(self.config, self.guild),
-        )
-
-        with Session(engine) as session:
-            stmt = select(ElectionInformation).where(
-                ElectionInformation.ElectionCycle == get_election_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)
+        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+        await election_channel.send(message)
 
     async def term_start_action(self) -> None:
         """
-        Marks the election as over.
+        Moves the election channel into the archive category.
         """
 
         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)
 
-        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_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))
-
-            election_cycle = get_election_name(self.config)
-            try:
-                dm_winner = max(dm_votes, key=dm_votes.get)
-                stmt = (
-                    update(CouncilMembers)
-                    .where(CouncilMembers.ElectionCycle == election_cycle)
-                    .where(CouncilMembers.MemberId == dm_winner)
-                    .values(DiscordManager=True)
-                )
-                session.execute(stmt)
-            except ValueError:
-                dm_winner = "No winner"
-            try:
-                cl_winner = max(cl_votes, key=cl_votes.get)
-                stmt = (
-                    update(CouncilMembers)
-                    .where(CouncilMembers.ElectionCycle == election_cycle)
-                    .where(CouncilMembers.MemberId == cl_winner)
-                    .values(ClanLeader=True)
-                )
-                session.execute(stmt)
-            except ValueError:
-                cl_winner = "No winner"
-
-            session.commit()
-
-        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_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)
-        await edit_clan_council_info(self.guild, self.config)
+        await election_channel.move(beginning=True, category=archive)
 
     def get_election_info(self) -> ElectionInformation:
         """
@@ -447,7 +272,7 @@ class ElectionCycle:
 
         with Session(engine) as session:
             stmt = select(ElectionInformation).where(
-                ElectionInformation.ElectionCycle == get_election_name(self.config)
+                ElectionInformation.ElectionCycle == get_election_cycle_name(self.config)
             )
             return session.scalar(stmt)
 
@@ -456,11 +281,9 @@ 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().ThreadId}> to cast your vote!"
+        message += f"to <#{self.get_election_info().ElectionChannel}> to cast your vote!"
 
         await general.send(content=message)

classes/gitea_webhook.py

@@ -1,195 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  gitea_webhook.json
-#   timestamp: 2024-05-16T21:15:27+00:00
-
-from __future__ import annotations
-
-from typing import List
-
-from pydantic import BaseModel
-
-
-class Author(BaseModel):
-    name: str
-    email: str
-    username: str
-
-
-class Committer(BaseModel):
-    name: str
-    email: str
-    username: str
-
-
-class Commit(BaseModel):
-    id: str
-    message: str
-    url: str
-    author: Author
-    committer: Committer
-    verification: None
-    timestamp: str
-    added: List[str]
-    removed: List[str]
-    modified: List[str]
-
-
-class HeadCommit(BaseModel):
-    id: str
-    message: str
-    url: str
-    author: Author
-    committer: Committer
-    verification: None
-    timestamp: str
-    added: List[str]
-    removed: List[str]
-    modified: List[str]
-
-
-class Owner(BaseModel):
-    id: int
-    login: str
-    login_name: str
-    full_name: str
-    email: str
-    avatar_url: str
-    language: str
-    is_admin: bool
-    last_login: str
-    created: str
-    restricted: bool
-    active: bool
-    prohibit_login: bool
-    location: str
-    website: str
-    description: str
-    visibility: str
-    followers_count: int
-    following_count: int
-    starred_repos_count: int
-    username: str
-
-
-class Permissions(BaseModel):
-    admin: bool
-    push: bool
-    pull: bool
-
-
-class Repository(BaseModel):
-    id: int
-    owner: Owner
-    name: str
-    full_name: str
-    description: str
-    empty: bool
-    private: bool
-    fork: bool
-    template: bool
-    parent: None
-    mirror: bool
-    size: int
-    language: str
-    languages_url: str
-    html_url: str
-    url: str
-    link: str
-    ssh_url: str
-    clone_url: str
-    original_url: str
-    website: str
-    stars_count: int
-    forks_count: int
-    watchers_count: int
-    open_issues_count: int
-    open_pr_counter: int
-    release_counter: int
-    default_branch: str
-    archived: bool
-    created_at: str
-    updated_at: str
-    archived_at: str
-    permissions: Permissions
-    has_issues: bool
-    has_wiki: bool
-    has_pull_requests: bool
-    has_projects: bool
-    has_releases: bool
-    has_packages: bool
-    has_actions: bool
-    ignore_whitespace_conflicts: bool
-    allow_merge_commits: bool
-    allow_rebase: bool
-    allow_rebase_explicit: bool
-    allow_squash_merge: bool
-    allow_rebase_update: bool
-    default_delete_branch_after_merge: bool
-    default_merge_style: str
-    default_allow_maintainer_edit: bool
-    avatar_url: str
-    internal: bool
-    mirror_interval: str
-    mirror_updated: str
-    repo_transfer: None
-
-
-class Pusher(BaseModel):
-    id: int
-    login: str
-    login_name: str
-    full_name: str
-    email: str
-    avatar_url: str
-    language: str
-    is_admin: bool
-    last_login: str
-    created: str
-    restricted: bool
-    active: bool
-    prohibit_login: bool
-    location: str
-    website: str
-    description: str
-    visibility: str
-    followers_count: int
-    following_count: int
-    starred_repos_count: int
-    username: str
-
-
-class Sender(BaseModel):
-    id: int
-    login: str
-    login_name: str
-    full_name: str
-    email: str
-    avatar_url: str
-    language: str
-    is_admin: bool
-    last_login: str
-    created: str
-    restricted: bool
-    active: bool
-    prohibit_login: bool
-    location: str
-    website: str
-    description: str
-    visibility: str
-    followers_count: int
-    following_count: int
-    starred_repos_count: int
-    username: str
-
-
-class GiteaWebhook(BaseModel):
-    ref: str
-    before: str
-    after: str
-    compare_url: str
-    commits: List[Commit]
-    total_commits: int
-    head_commit: HeadCommit
-    repository: Repository
-    pusher: Pusher
-    sender: Sender

classes/nominate_highcouncil_views.py

@@ -1,266 +0,0 @@
-"""
-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_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_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_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_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_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,7 +9,9 @@ from sqlalchemy.orm import Session
 
 from config import DakinyConfig
 from database_setup.sql_data_classes import CouncilMembers, engine
-from utils import NOMINEE_SPLITTER, decorate_nomination, get_election_name
+from utils import get_election_cycle_name
+
+NOMINEE_SPLITTER = "========================================\n\n"
 
 
 class NominateModal(nextcord.ui.Modal):
@@ -17,13 +19,7 @@ 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
@@ -58,7 +54,7 @@ class NominateModal(nextcord.ui.Modal):
                 msg = await interaction.channel.send(speech)
 
                 council_member = CouncilMembers(
-                    ElectionCycle=get_election_name(self.config),
+                    ElectionCycle=get_election_cycle_name(self.config),
                     MemberId=interaction.user.id,
                     SpeechMsgId=msg.id,
                 )
@@ -66,7 +62,7 @@ class NominateModal(nextcord.ui.Modal):
                 session.commit()
             else:
                 # user already nominated, just need to update the election speech
-                cycle = get_election_name(self.config)
+                cycle = get_election_cycle_name(self.config)
                 stmt = (
                     select(CouncilMembers)
                     .where(CouncilMembers.ElectionCycle == cycle)
@@ -74,12 +70,8 @@ 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):
@@ -87,19 +79,12 @@ class NominateView(nextcord.ui.View):
     The button to press to start your nomination.
     """
 
-    def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
+    def __init__(self, config):
         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.
@@ -109,18 +94,7 @@ 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_name(self.config)
+        cycle = get_election_cycle_name(self.config)
         usr_nominated = False
         speech_content = ""
         with Session(engine) as session:
@@ -136,7 +110,23 @@ 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

@@ -1,263 +0,0 @@
-"""
-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_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_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, interaction.guild)
-        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_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 sorted(
-                    session.scalars(stmt),
-                    key=lambda nominee: self.guild.get_member(nominee).display_name,
-                )
-            ]
-            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_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 sorted(
-                    session.scalars(stmt),
-                    key=lambda nominee: self.guild.get_member(nominee).display_name,
-                )
-            ]
-            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,17 +7,12 @@ from typing import List
 import nextcord
 from nextcord import SelectOption
 from nextcord.interactions import Interaction
-from sqlalchemy import exc, select, update
+from sqlalchemy import exc, select
 from sqlalchemy.orm import Session
 
 from config import DakinyConfig
-from database_setup.sql_data_classes import (
-    CouncilMembers,
-    ElectionInformation,
-    Votes,
-    engine,
-)
-from utils import build_votes_str, get_election_name
+from database_setup.sql_data_classes import CouncilMembers, ElectionInformation, Votes, engine
+from utils import build_votes_str, get_election_cycle_name
 
 
 class VoteSelect(nextcord.ui.StringSelect):
@@ -31,7 +26,7 @@ class VoteSelect(nextcord.ui.StringSelect):
         self.config = config
 
     async def callback(self, interaction: Interaction):
-        election_name = get_election_name(self.config)
+        election_name = get_election_cycle_name(self.config)
         with Session(engine) as session:
             stmt = select(ElectionInformation.CouncilVoteMsgId).where(
                 ElectionInformation.ElectionCycle == election_name
@@ -43,11 +38,7 @@ 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)
@@ -56,18 +47,16 @@ class VoteSelect(nextcord.ui.StringSelect):
             except exc.IntegrityError:
                 session.rollback()
                 stmt = (
-                    update(Votes)
+                    select(Votes)
                     .where(Votes.ElectionCycle == election_name)
                     .where(Votes.VoterId == interaction.user.id)
-                    .values(VotedForId=voted_for)
                 )
-                session.execute(stmt)
+                vote = session.scalar(stmt)
+                vote.VotedForId = voted_for
                 session.commit()
 
-        vote_message_str = build_votes_str(self.config, interaction.guild)
-        vote_msg: nextcord.Message = await interaction.channel.fetch_message(
-            vote_msg_id
-        )
+        vote_message_str = build_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:
@@ -88,15 +77,10 @@ class VoteView(nextcord.ui.View):
         self.config = config
         self.guild = guild
 
-    @nextcord.ui.button(
-        label="Vote", style=nextcord.ButtonStyle.primary, custom_id="vote"
-    )
-    async def vote(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ) -> None:
+    @nextcord.ui.button(label="Vote", style=nextcord.ButtonStyle.primary, custom_id="vote")
+    async def vote(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:
         """
-        Enforces only members vote. Gets election cycle, creates voting options (checking if user has voted already),
-        then sends the voting view.
+        TODO
 
         Args:
             button (nextcord.ui.Button): Unused. idk why its needed in the decorator
@@ -104,17 +88,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
 
-        election: str = get_election_name(self.config)
+        election: str = get_election_cycle_name(self.config)
 
         with Session(engine) as session:
             stmt = (
@@ -124,30 +104,18 @@ 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).display_name} ☑️"
-                        if voted_for == nominee
-                        else f"{self.guild.get_member(nominee).display_name}"
-                    ),
+                    label=f"{self.guild.get_member(nominee).nick} ☑️"
+                    if voted_for == nominee
+                    else f"{self.guild.get_member(nominee).nick}",
                     value=str(nominee),
                 )
-                for nominee in sorted(
-                    session.scalars(stmt),
-                    key=lambda nominee: self.guild.get_member(nominee).display_name,
-                )
+                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/clan_messages/__init__.py

@@ -1,105 +0,0 @@
-"""
-File contains logic for creating a webhook listener, pulling from git, and updating all messages.
-"""
-
-import os
-
-import nextcord
-import uvicorn
-from fastapi import FastAPI
-from git import Repo
-from nextcord.ext import commands
-
-from classes.gitea_webhook import GiteaWebhook
-from config import DakinyConfig
-from utils import REPO_DIR, edit_clan_council_info, update_clan_messages
-
-app = FastAPI()
-REPO_URL = "https://gitea.cheezers.org/imcompiling/dakiny-messages.git"
-
-
-class ClanMessages(commands.Cog, name="Clan Messages"):
-    """
-    Cog to be loaded into the bot. Used to be able to have a fastapi post listener and access to the bot at
-    the same time.
-    """
-
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-        self.config: DakinyConfig = self.bot.config
-        self.repo_setup()
-
-    @commands.Cog.listener()
-    async def on_ready(self):
-        """
-        Triggers when the bot is in ready state. Adds the webhook listener to FastAPI and serves.
-        """
-        app.add_api_route("/messages/", self.update_messages, methods=["POST"])
-        config = uvicorn.Config(app=app, host="0.0.0.0", port=5000, log_level="info")
-        server = uvicorn.Server(config)
-        await server.serve()
-
-    async def update_messages(self, hook_info: GiteaWebhook):
-        """
-        Pulls from git and then calls method to update all the discord messages as described by the
-        files in the git repo.
-        """
-
-        # Get all modified/added files
-        modified_files: list[str] = [
-            file
-            for list in [commit.modified + commit.added for commit in hook_info.commits]
-            for file in list
-        ]
-
-        template_updates = {
-            file.split("/")[1] for file in modified_files if "message_templates" in file
-        }
-        channel_updates = {
-            file.split("/")[1]
-            for file in modified_files
-            if file.split("/")[1] not in template_updates
-        }
-
-        self.origin.pull()
-        guild: nextcord.Guild = self.bot.get_guild(self.config.params.guild_id)
-
-        await update_clan_messages(guild, channel_updates)
-
-        # if the council members template has changed, update the message
-        if "council_members.txt" in template_updates:
-            await edit_clan_council_info(
-                self.bot.get_guild(self.config.params.guild_id), self.config
-            )
-
-        return {"message": "Successfully updated all discord messages."}
-
-    def repo_setup(self):
-        """
-        Checks if the repo exists and creates repo object, clones if it does not.
-        """
-        # check if repo has been cloned. open repo object
-        if os.path.isdir(REPO_DIR):
-            self.repo = Repo(REPO_DIR)
-        else:
-            self.repo = Repo.clone_from(REPO_URL, REPO_DIR)
-
-        self.origin = self.repo.remote("origin")
-
-        if self.config.params.git_branch == "test":
-            self.repo.create_head("test", self.origin.refs.test).set_tracking_branch(
-                self.origin.refs.test
-            ).checkout()
-        else:
-            self.repo.create_head("main", self.origin.refs.main).set_tracking_branch(
-                self.origin.refs.main
-            ).checkout()
-
-        self.origin.pull()
-
-
-# This function will be called when this extension is loaded.
-# It is necessary to add these functions to the bot.
-def setup(bot: commands.Bot):
-    """Adds function to bot"""
-    bot.add_cog(ClanMessages(bot))

cogs/commands/__init__.py

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

cogs/commands/record.py

@@ -1,218 +0,0 @@
-"""
-Contained commands and views for record commands.
-"""
-
-import nextcord
-from discord import TextInputStyle
-from nextcord.ext import commands
-
-from config import DakinyConfig
-from utils import record_event_host, record_event_participation
-
-
-class RecordCog(commands.Cog, name="Record Commands"):
-    """
-    Class holds record commands.
-    """
-
-    def __init__(self, bot) -> None:
-        """
-        Default constructor for RecordCog class. Does nothing.
-        """
-        super().__init__()
-        self.bot: commands.Bot = bot
-
-    @nextcord.slash_command()
-    async def record(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for record. Never called.
-        """
-
-    @record.subcommand(description="Record an event and its participants.")
-    async def event(
-        self,
-        interaction: nextcord.Interaction,
-        name: str = nextcord.SlashOption(
-            required=True, description="Name of the event that was hosted."
-        ),
-        host: nextcord.Member = nextcord.SlashOption(
-            required=False,
-            description="An alternative host if you are recording event for someone else.",
-        ),
-    ):
-        """
-        This command creates the base event recording embed and sends a message with it and the EventView
-        for gathering more information on the event.
-
-        Args:
-            interaction (nextcord.Interaction): interaction with this command.
-            name (str): Name of the event.
-            host (nextcord.Member, optional): Alternative host to user using command.
-        """
-
-        # check role
-        if (
-            interaction.guild.get_role(self.bot.config.params.event_host_role_id)
-            not in interaction.user.roles
-        ):
-            await interaction.response.send_message(
-                f"You must have the <@&{self.bot.config.params.event_host_role_id}> role to record an event.",
-                ephemeral=True,
-            )
-            return
-
-        if host is None:
-            host = interaction.user
-
-        embed: nextcord.Embed = nextcord.Embed(title=name, description="")
-        embed.add_field(name="Participants", value="")
-        embed.add_field(name="Non-Discord Participants", value="")
-        embed.add_field(name="Hosted by", value=f"<@{host.id}>", inline=False)
-
-        await interaction.response.send_message(
-            "Fill out event details and select all members who participated!",
-            view=EventView(name, self.bot.config, host.id),
-            ephemeral=True,
-            embed=embed,
-        )
-
-
-class EventView(nextcord.ui.View):
-    """
-    Class handles gathering information on an event. Has buttons to edit the information, cancel, and submit.
-    Also contains a UserSelect object to pick discord members.
-    """
-
-    def __init__(self, name: str, config: DakinyConfig, host_id: int):
-        super().__init__()
-
-        self.name: str = name
-        self.config: DakinyConfig = config
-        self.host_id: int = host_id
-
-        self.event_participants = ParticipantSelect()
-
-        self.add_item(self.event_participants)
-
-    @nextcord.ui.button(label="Cancel", style=nextcord.ButtonStyle.red, row=1)
-    async def cancel(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):
-        """
-        Cancels event submission. Removes embed and view.
-        """
-        await interaction.response.edit_message(
-            "Canceled", ephemeral=True, embed=None, view=None
-        )
-        self.stop()
-
-    @nextcord.ui.button(label="Edit", style=nextcord.ButtonStyle.blurple, row=1)
-    async def edit(self, button: nextcord.ui.Button, interaction: nextcord.Interaction):
-        """
-        Calls modal to update the text input information of the event.
-        """
-        await interaction.response.send_modal(
-            ParticipantModal(interaction.message.embeds[0])
-        )
-
-    @nextcord.ui.button(label="Confirm", style=nextcord.ButtonStyle.green, row=1)
-    async def confirm(
-        self, button: nextcord.ui.Button, interaction: nextcord.Interaction
-    ):
-        """
-        Submits the event embed to the event channel. Removes view and embed from recording message.
-        Sends point information to database.
-        """
-
-        discord_users = self.event_participants.values.members
-        if discord_users:
-            discord_users_list: list[str] = [
-                str(user.id) for user in discord_users if user.id is not self.host_id
-            ]
-            record_event_participation(self.config, discord_users_list, True)
-
-        non_discord_users = interaction.message.embeds[0].fields[1].value
-        if non_discord_users:
-            non_discord_users_list: list[str] = non_discord_users.split("\n")
-            record_event_participation(self.config, non_discord_users_list, False)
-
-        record_event_host(self.config, self.host_id)
-
-        event_channel: nextcord.TextChannel = interaction.guild.get_channel(
-            self.config.params.event_post_channel_id
-        )
-        await event_channel.send(embed=interaction.message.embeds[0])
-        await interaction.response.edit_message(
-            content="Event has been submitted.", view=None, embed=None
-        )
-
-        self.stop()
-
-
-class ParticipantModal(nextcord.ui.Modal):
-    """
-    This modal contains all the text edits for an event. You can change the name, description, and add the usernames
-    of participants who are not in the discord.
-    """
-
-    # TODO turn this embed into a dict
-    def __init__(self, embed):
-        super().__init__(
-            "Edit the event.",
-            timeout=5 * 60,
-        )
-        self.embed: nextcord.Embed = embed
-        self.name: nextcord.ui.TextInput = nextcord.ui.TextInput(
-            required=True,
-            label="Event Name",
-            default_value=self.embed.title,
-        )
-        self.description: nextcord.ui.TextInput = nextcord.ui.TextInput(
-            required=False,
-            label="Event Description",
-            default_value=self.embed.description,
-            style=TextInputStyle.paragraph,
-            placeholder="Add a description if desired.",
-            max_length=1000,
-        )
-        self.participants: nextcord.ui.TextInput = nextcord.ui.TextInput(
-            required=False,
-            label="Non-Discord Usernames",
-            style=TextInputStyle.paragraph,
-            placeholder="Please separate usernames with a new line.",
-            default_value=self.embed.fields[1].value,
-        )
-        self.add_item(self.name)
-        self.add_item(self.description)
-        self.add_item(self.participants)
-
-    async def callback(self, interaction: nextcord.Interaction):
-        self.embed.title = self.name.value
-        self.embed.description = self.description.value
-        self.embed.set_field_at(
-            index=1, name="Non-Discord Participants", value=self.participants.value
-        )
-
-        await interaction.response.edit_message(embed=self.embed)
-
-
-class ParticipantSelect(nextcord.ui.UserSelect):
-    """
-    A selection drop down for discord members. Updates the embed with all users selected.
-    """
-
-    def __init__(self) -> None:
-        super().__init__(
-            min_values=1,
-            max_values=25,
-            placeholder="Select all participants",
-            row=0,
-        )
-
-    async def callback(self, interaction: nextcord.Interaction):
-        embed: nextcord.Embed = interaction.message.embeds[0]
-        participants: str = "\n".join(
-            [f"<@{participant.id}>" for participant in self.values.members]
-        )
-        embed.set_field_at(0, name="Participants", value=participants)
-        await interaction.response.edit_message(embed=embed)

cogs/commands/refresh.py

@@ -1,74 +0,0 @@
-"""
-Contained commands and views for refresh commands.
-"""
-
-import os
-
-import nextcord
-from nextcord.ext import commands
-
-from utils import MESSAGES_DIR, edit_clan_council_info, update_clan_messages
-
-
-class RefreshCog(commands.Cog, name="Refresh Commands"):
-    """
-    Class holds refresh commands.
-    """
-
-    def __init__(self, bot) -> None:
-        """
-        Default constructor for RefreshCog class. Does nothing.
-        """
-        super().__init__()
-        self.bot: commands.Bot = bot
-
-    @nextcord.slash_command(
-        default_member_permissions=nextcord.Permissions(administrator=True)
-    )
-    async def refresh(self, interaction: nextcord.Interaction):
-        """
-        Parent slash command for refresh. Never called.
-        """
-
-    @refresh.subcommand(description="Force refresh all of the bot managed messages.")
-    async def messages(
-        self,
-        interaction: nextcord.Interaction,
-        channel: nextcord.TextChannel = nextcord.SlashOption(
-            description="Channel to refresh messages in.",
-            required=False,
-        ),
-    ):
-        """
-        Calls update_clan_messages() to update all messages.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with the command.
-            channel (nextcord.TextChannel): channel to refresh messages in.
-        """
-        await interaction.response.defer(ephemeral=True)
-
-        if channel is None:
-            channel_updates = [
-                dir_name
-                for dir_name in os.listdir(MESSAGES_DIR)
-                if os.path.isdir(f"{MESSAGES_DIR}/{dir_name}")
-            ]
-        else:
-            channel_updates = [channel.name]
-
-        await update_clan_messages(interaction.guild, channel_updates)
-        await interaction.followup.send("Messages have been refreshed.", ephemeral=True)
-
-    @refresh.subcommand(description="Updates the current council info message.")
-    async def council_info(self, interaction: nextcord.Interaction):
-        """
-        Calls edit_clan_council_info().
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with the command.
-        """
-        await edit_clan_council_info(interaction.guild, self.bot.config)
-        await interaction.response.send_message(
-            "Clan Council Info message updated.", ephemeral=True
-        )

cogs/commands/remove.py

@@ -1,86 +0,0 @@
-"""
-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,10 +4,8 @@ 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"):
@@ -24,49 +22,15 @@ class RequestCog(commands.Cog, name="Request Commands"):
     @nextcord.slash_command()
     async def request(self, interaction: nextcord.Interaction):
         """
-        Parent slash command for request. Never called.
+        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."
         ),
     ):
         """
@@ -80,12 +44,8 @@ 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):
@@ -93,19 +53,13 @@ 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,
-    ):
-        super().__init__(timeout=None, auto_defer=True)
+    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)
         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.
@@ -119,10 +73,7 @@ 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(
@@ -133,13 +84,10 @@ 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)
@@ -153,50 +101,3 @@ 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/set.py

@@ -10,8 +10,8 @@ from sqlalchemy import delete, select
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 
+from dakiny_bot import birthday_list
 from database_setup.sql_data_classes import UserBirthday, engine
-from main import birthday_list
 
 
 class setCog(commands.Cog, name="Set Commands"):
@@ -30,18 +30,12 @@ class setCog(commands.Cog, name="Set Commands"):
         Parent slash command for set. Never called.
         """
 
-    @set.subcommand(
-        description="Sets your birth month and day for the Birthday Fun. Use 0/0 to remove yourself."
-    )
+    @set.subcommand(description="Sets your birth month and day for the Birthday Fun. Use 0/0 to remove yourself.")
     async def birthday(
         self,
         interaction: nextcord.Interaction,
-        month: int = nextcord.SlashOption(
-            required=True, min_value=0, max_value=12, description="Your birth month."
-        ),
-        day: int = nextcord.SlashOption(
-            required=True, min_value=0, max_value=31, description="Your birth day."
-        ),
+        month: int = nextcord.SlashOption(required=True, min_value=0, max_value=12, description="Your birth month."),
+        day: int = nextcord.SlashOption(required=True, min_value=0, max_value=31, description="Your birth day."),
     ):
         """
         Sets a user's birthday in the database. Removes on input 0/0. If birthday is today, adds to the birthday_list.
@@ -56,9 +50,7 @@ class setCog(commands.Cog, name="Set Commands"):
         await interaction.response.defer(ephemeral=True)
 
         if month == 0 and day == 0:
-            stmt = delete(UserBirthday).where(
-                UserBirthday.UserId == interaction.user.id
-            )
+            stmt = delete(UserBirthday).where(UserBirthday.UserId == interaction.user.id)
             with Session(engine) as session:
                 session.execute(stmt)
                 session.commit()
@@ -70,18 +62,14 @@ class setCog(commands.Cog, name="Set Commands"):
         try:
             birthday = datetime(today.year, month, day)
         except ValueError:
-            await interaction.followup.send(
-                f"Invalid date: {month}/{day}.", ephemeral=True
-            )
+            await interaction.followup.send(f"Invalid date: {month}/{day}.", ephemeral=True)
             return
 
         # If the birthday is today, add to birthday_list
         if today.date() == birthday.date():
             birthday_list.append(interaction.user.id)
 
-        new_birthday = UserBirthday(
-            UserId=interaction.user.id, Birthday=f"{month}/{day}"
-        )
+        new_birthday = UserBirthday(UserId=interaction.user.id, Birthday=f"{month}/{day}")
         with Session(engine) as session:
             try:
                 session.add(new_birthday)
@@ -89,13 +77,9 @@ class setCog(commands.Cog, name="Set Commands"):
             except IntegrityError:
                 # User already has birthday, change it instead.
                 session.rollback()
-                stmt = select(UserBirthday).where(
-                    UserBirthday.UserId == interaction.user.id
-                )
+                stmt = select(UserBirthday).where(UserBirthday.UserId == interaction.user.id)
                 new_birthday = session.scalar(stmt)
                 new_birthday.Birthday = f"{month}/{day}"
                 session.commit()
 
-        await interaction.followup.send(
-            f"Birthday set to {month}/{day}.", ephemeral=True
-        )
+        await interaction.followup.send(f"Birthday set to {month}/{day}.", ephemeral=True)

cogs/commands/test.py

@@ -7,18 +7,7 @@ from nextcord.ext import application_checks, commands
 
 from classes.election_cycle import ElectionCycle
 from config import DakinyConfig
-from utils import get_current_election_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)
+from utils import get_current_cycle
 
 
 class TestCog(commands.Cog, name="Test commands."):
@@ -32,14 +21,37 @@ class TestCog(commands.Cog, name="Test commands."):
         """
         self.bot = bot
 
-    @nextcord.slash_command(guild_ids=[1000247361639030804])
+    def is_me():
+        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()
-    @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()
     async def election_start(self, interaction: nextcord.Interaction):
         """
         idc
@@ -49,15 +61,10 @@ class TestCog(commands.Cog, name="Test commands."):
         """
 
         config: DakinyConfig = self.bot.config
-        cycle = ElectionCycle(
-            get_current_election_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
@@ -66,15 +73,10 @@ class TestCog(commands.Cog, name="Test commands."):
             interaction (nextcord.Interaction): _description_
         """
         config: DakinyConfig = self.bot.config
-        cycle = ElectionCycle(
-            get_current_election_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
@@ -83,59 +85,17 @@ class TestCog(commands.Cog, name="Test commands."):
             interaction (nextcord.Interaction): _description_
         """
         config: DakinyConfig = self.bot.config
-        cycle = ElectionCycle(
-            get_current_election_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_election_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_election_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_election_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_election_cycle(config),
-            config,
-            self.bot.get_guild(config.params.guild_id),
-        )
-        await cycle.term_start_action()

cogs/commands/view.py

@@ -3,17 +3,11 @@ Commands for viewing information in the database.
 """
 
 import nextcord
-import pandas as pd
 from nextcord.ext import commands
 from sqlalchemy import select
 from sqlalchemy.orm import Session
 
-from database_setup.sql_data_classes import (
-    ParticipationPoints,
-    Presences,
-    Votes,
-    engine,
-)
+from database_setup.sql_data_classes import ElectionInformation, Votes, engine
 
 
 class ViewCog(commands.Cog, name="View Commands"):
@@ -32,113 +26,6 @@ class ViewCog(commands.Cog, name="View Commands"):
         Parent slash command for set. Never called.
         """
 
-    @view.subcommand(description="Show event points.")
-    async def event_points(
-        self,
-        interaction: nextcord.Interaction,
-        quarter_name: str = nextcord.SlashOption(
-            description="The quarter to view",
-            required=False,
-        ),
-    ):
-        # just in case
-        await interaction.response.defer(ephemeral=True)
-
-        with Session(engine) as session:
-            if quarter_name:
-                df = pd.read_sql_query(
-                    sql=session.query(ParticipationPoints)
-                    .where(ParticipationPoints.Cycle.startswith(quarter_name))
-                    .statement,
-                    con=engine,
-                )
-            else:
-                df = pd.read_sql_query(
-                    sql=session.query(ParticipationPoints).statement,
-                    con=engine,
-                )
-
-            if df.empty:
-                await interaction.followup.send(
-                    f'Quarter "{quarter_name}" is invalid.', ephemeral=True
-                )
-                return
-
-            cycles = df.groupby("Cycle")
-            content = ""
-            for cycle in cycles.groups:
-                content += f"**{cycle}**\n"
-                unsorted_all = cycles.get_group(cycle).groupby("DiscordMember")
-                members = unsorted_all.get_group(True)
-                non_members = unsorted_all.get_group(False)
-                sorted_members = members.sort_values(
-                    by="UserId",
-                    key=lambda user_ids: (
-                        [
-                            interaction.guild.get_member(int(id)).display_name
-                            for id in user_ids
-                        ]
-                    ),
-                )
-                sorted_non_members = non_members.sort_values(by="UserId")
-                sorted_all = pd.concat(
-                    [sorted_members, sorted_non_members], ignore_index=True, sort=False
-                )
-                for row in sorted_all.itertuples():
-                    userid = row.UserId
-                    points = row.Points
-                    discord_member = row.DiscordMember
-                    content += (
-                        f"<@{userid}>: {points}\n"
-                        if discord_member
-                        else f"{userid}: {points}\n"
-                    )
-                content += "\n"
-
-            if len(content) > 2000:
-                await interaction.followup.send(
-                    "Message length is too long, please select search to limit results."
-                )
-                return
-
-            await interaction.followup.send(content=content, ephemeral=True)
-
-    @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."
     )
@@ -193,12 +80,12 @@ class ViewCog(commands.Cog, name="View Commands"):
         """
 
         with Session(engine) as session:
-            stmt = select(Votes.ElectionCycle).distinct()
+            stmt = select(ElectionInformation.ElectionCycle)
             elections = session.scalars(stmt)
 
             # if empty compare string
             if not election_name:
-                await interaction.response.send_autocomplete(list(elections)[:25])
+                await interaction.response.send_autocomplete(elections)
                 return
 
             autofilled_elections: "list[str]" = [
@@ -207,31 +94,3 @@ class ViewCog(commands.Cog, name="View Commands"):
                 if election.lower().startswith(election_name.lower())
             ]
             await interaction.response.send_autocomplete(autofilled_elections[:25])
-
-    @event_points.on_autocomplete("quarter_name")
-    async def event_points_autocomplete(
-        self, interaction: nextcord.Interaction, quarter_name: str
-    ):
-        """
-        Collects all elections that start with the election string.
-
-        Args:
-            interaction (nextcord.Interaction): Interaction with command.
-            quarter_name (str): String to run autocomplete on.
-        """
-
-        with Session(engine) as session:
-            stmt = select(ParticipationPoints.Cycle).distinct()
-            quarters = session.scalars(stmt)
-
-            # if empty compare string
-            if not quarter_name:
-                await interaction.response.send_autocomplete(list(quarters)[:25])
-                return
-
-            autofilled_quarters: "list[str]" = [
-                quarter
-                for quarter in quarters
-                if quarter.lower().startswith(quarter_name.lower())
-            ]
-            await interaction.response.send_autocomplete(autofilled_quarters[:25])

cogs/loops/__init__.py

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

cogs/loops/bot_presence.py

@@ -1,48 +0,0 @@
-"""
-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)
-        )

cogs/loops/daily_loop.py

@@ -13,9 +13,9 @@ from sqlalchemy.orm import Session
 
 from classes.election_cycle import ElectionCycle
 from config import DakinyConfig
+from dakiny_bot import birthday_list
 from database_setup.sql_data_classes import UserBirthday, engine
-from main import birthday_list
-from utils import get_current_election_cycle
+from utils import get_current_cycle
 
 
 class DailyLoop(commands.Cog, name="Daily Loop"):
@@ -77,11 +77,7 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
         """
 
         config: DakinyConfig = self.bot.config
-        cycle = get_current_election_cycle(config)
-
-        # prevent exception from using cycle as an Int in an array
-        if cycle is None:
-            return None
+        cycle = get_current_cycle(config)
 
         return ElectionCycle(cycle, config, self.bot.get_guild(config.params.guild_id))
 
@@ -111,14 +107,10 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
 
         today = datetime.today()
         guild: nextcord.Guild = self.bot.get_guild(self.bot.config.params.guild_id)
-        announce_channel: nextcord.TextChannel = guild.get_channel(
-            self.bot.config.params.general_channel_id
-        )
+        announce_channel: nextcord.TextChannel = guild.get_channel(self.bot.config.params.general_channel_id)
 
         cakedays: list[nextcord.Member] = [
-            human
-            for human in guild.humans
-            if human.joined_at.month == today.month and human.joined_at.day == today.day
+            human for human in guild.humans if human.joined_at.month == today.month and human.joined_at.day == today.day
         ]
 
         for member in cakedays:

cogs/message_listener/__init__.py

@@ -5,7 +5,7 @@ Defines cog for on message listener.
 import nextcord
 from nextcord.ext import commands
 
-from main import birthday_list
+from dakiny_bot import birthday_list
 
 
 class SubmissionListener(commands.Cog, name="Message Listener"):
@@ -39,7 +39,5 @@ async def birthday_action(message: nextcord.Message) -> None:
         message (nextcord.Message): The message to check for a birthday person.
     """
 
-    if message.author.id in birthday_list or bool(
-        set(message.raw_mentions) & set(birthday_list)
-    ):
+    if message.author.id in birthday_list or bool(set(message.raw_mentions) & set(birthday_list)):
         await message.add_reaction("🎂")

config.py

@@ -1,7 +1,6 @@
 """
 File contains classes defining the Hydra configuraton structure.
 """
-
 from dataclasses import dataclass
 
 
@@ -11,22 +10,18 @@ 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
     clan_member_role_id: int
     discord_token: str
-    event_host_points: int
-    event_host_role_id: int
-    event_participate_points: int
-    event_post_channel_id: int
     general_channel_id: int
-    git_branch: str
     guild_id: int
     high_council_role_id: int
-    voting_parent_id: int
 
 
 @dataclass

dakiny_bot.py

@@ -8,9 +8,7 @@ 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
 
@@ -22,9 +20,7 @@ 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)
 
 
@@ -55,10 +51,8 @@ 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.get_guild(cfg.params.guild_id)))
-        bot.add_view(NominateHighCouncilView(cfg, bot.get_guild(cfg.params.guild_id)))
+        bot.add_view(NominateView(cfg))
         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,22 +1,18 @@
 CREATE TABLE ElectionInformation(
     ElectionCycle varchar(30) not null unique,
-    ThreadId bigint unsigned not null,
+    ElectionChannel bigint unsigned not null,
     CouncilVoteMsgId bigint unsigned,
-    HighCouncilVoteMsgId bigint unsigned,
-    CouncilNominationMsgId bigint unsigned,
-    HighCouncilNominationMsgId bigint unsigned,
     PRIMARY KEY (ElectionCycle)
 );
 
 CREATE TABLE CouncilMembers(
     ElectionCycle varchar(30) not null,
     MemberId bigint unsigned not null,
-    SpeechMsgId 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)
 );
@@ -34,21 +30,3 @@ CREATE TABLE UserBirthday (
     Birthday varchar(5) not null,
     PRIMARY KEY (UserId)
 );
-
-CREATE TABLE Presences (
-    Id integer PRIMARY KEY,
-    Presence varchar(100) not null
-);
-
-CREATE TABLE ParticipationPoints (
-    Cycle varchar(30) not null,
-    UserId varchar(32) not null,
-    DiscordMember boolean not null,
-    Points int unsigned DEFAULT 0,
-    PRIMARY KEY (Cycle, UserId)
-);
-
-CREATE TABLE Messages (
-    Path varchar(100) PRIMARY KEY,
-    Id bigint unsigned not null
-);

database_setup/sql_data_classes.py

@@ -1,7 +1,6 @@
 """
 Simple file to set up the sqlalchemy connection to database.
 """
-
 from sqlalchemy import create_engine
 from sqlalchemy.ext.automap import automap_base
 
@@ -12,10 +11,7 @@ Base = automap_base()
 Base.prepare(autoload_with=engine)
 
 # define the classes
-CouncilMembers = Base.classes.CouncilMembers
 ElectionInformation = Base.classes.ElectionInformation
-Messages = Base.classes.Messages
-ParticipationPoints = Base.classes.ParticipationPoints
-Presences = Base.classes.Presences
-UserBirthday = Base.classes.UserBirthday
+CouncilMembers = Base.classes.CouncilMembers
 Votes = Base.classes.Votes
+UserBirthday = Base.classes.UserBirthday

pyproject.toml

@@ -1,22 +0,0 @@
-[tool.poetry]
-name = "dakiny-bot"
-version = "0.1.0"
-description = "Dakiny's Discord Bot."
-authors = ["imcompiling <[email protected]>"]
-readme = "README.md"
-
-[tool.poetry.dependencies]
-python = "^3.11"
-gitpython = "3.1.43"
-fastapi = "0.111.0"
-hydra-core = "1.3.2"
-nextcord = "2.4.2"
-pandas = "1.5.2"
-python-dotenv = "1.0.0"
-pytz = "2022.7.1"
-sqlalchemy = "1.4.46"
-
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,5 @@
+nextcord==2.4.2
+python-dotenv==1.0.0
+pytz==2022.7.1
+hydra-core==1.3.2
+sqlalchemy<2.0

utils.py

@@ -2,27 +2,13 @@
 File contains util functions.
 """
 
-import os
 from datetime import datetime
-from typing import Iterable
 
-import nextcord
-from sqlalchemy import select, true, update
+from sqlalchemy import select
 from sqlalchemy.orm import Session
 
 from config import DakinyConfig
-from database_setup.sql_data_classes import (
-    CouncilMembers,
-    Messages,
-    ParticipationPoints,
-    Votes,
-    engine,
-)
-
-NOMINEE_SPLITTER = "========================================\n\n"
-REPO_DIR = "./dakiny-messages"
-MESSAGES_DIR = f"{REPO_DIR}/messages"
-TEMPLATES_DIR = f"{REPO_DIR}/message_templates"
+from database_setup.sql_data_classes import CouncilMembers, Votes, engine
 
 
 def get_datetime(day: str) -> datetime:
@@ -40,77 +26,26 @@ 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 and month < 12:
+    if datetime.today().month == 12 & month < 12:
         year += 1
 
-    if datetime.today().month == 1 and month > 1:
-        year -= 1
-
     return datetime(year, month, day)
 
 
-def get_election_name(config: DakinyConfig) -> str:
+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_election_cycle(config)
-    current_cycle = config.election_cycles[cycle]
-    return f"vote-{get_datetime(current_cycle.term_start).year}-{current_cycle.name}"
-
-
-def get_quarter_name(config: DakinyConfig) -> str:
-    """
-    Builds the name of the current cycle/quarter
-
-    Args:
-        config (DakinyConfig): the config used to know the election cycle.
-
-    Returns:
-        str: the name of the cycle.
-    """
-
-    cycle = get_quarter_cycle(config)
+    cycle = get_current_cycle(config)
     current_cycle = config.election_cycles[cycle]
 
-    return f"{get_datetime(current_cycle.term_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_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_name(config)}-cl"
-
-
-def get_current_election_cycle(config: DakinyConfig) -> int:
+def get_current_cycle(config: DakinyConfig) -> int:
     """
     Returns index for active election. An election is considered active between the election start and the term start.
 
@@ -118,7 +53,7 @@ def get_current_election_cycle(config: DakinyConfig) -> int:
         config (DakinyConfig): Config object to use
 
     Returns:
-        int: cycle index for active election. None for no active cycle
+        int: cycle index for active election. -1 for no active cycle
     """
 
     today = datetime.today()
@@ -130,39 +65,15 @@ def get_current_election_cycle(config: DakinyConfig) -> int:
         ):
             return cycle
 
-    # It isn't a current election, get the quarter
-    return get_quarter_cycle(config)
+    return -1
 
 
-def get_quarter_cycle(config: DakinyConfig) -> int:
-    """
-    Returns the index for the current cycle/quarter. Defined as between term start and end. Shouldn't return none
-
-    Args:
-        config (DakinyConfig): Config object to use
-
-    Returns:
-        int: cycle index for current cycle.
-    """
-
-    today = datetime.today()
-    for cycle, election in enumerate(config.election_cycles):
-        if (
-            today.date() >= get_datetime(election.term_start).date()
-            and today.date() <= get_datetime(election.term_end).date()
-        ):
-            return cycle
-
-    return None
-
-
-def build_votes_str(config: DakinyConfig, guild: nextcord.Guild) -> str:
+def build_votes_str(config: DakinyConfig) -> str:
     """
     Creates a string that contains all nominees and their votes to be sent as a discord message.
 
     Args:
         config (DakinyConfig): Daking config object
-        guild (nextcord.Guild): The guild object. Used to get display names for sorting.
 
     Returns:
         str: String that contains all nominees and their votes.
@@ -171,418 +82,22 @@ def build_votes_str(config: DakinyConfig, guild: nextcord.Guild) -> str:
     votes: dict[int, int] = {}
 
     with Session(engine) as session:
-        stmt = select(CouncilMembers).where(
-            CouncilMembers.ElectionCycle == get_election_name(config)
-        )
+        stmt = select(CouncilMembers).where(CouncilMembers.ElectionCycle == get_election_cycle_name(config))
 
-        for nominee in sorted(
-            session.scalars(stmt),
-            key=lambda nominee: guild.get_member(nominee.MemberId).display_name,
-        ):
+        for nominee in session.scalars(stmt):
             votes[nominee.MemberId] = 0
 
-        stmt = select(Votes).where(Votes.ElectionCycle == get_election_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 = "===================="
-    votes_str += user_vote_str(votes)
-
-    return votes_str
-
-
-def build_highcouncil_votes_str(config: DakinyConfig, guild: nextcord.Guild) -> 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.
-        guild (nextcord.Guild): The guild object. Used to get display names for sorting.
-    """
-
-    cl_votes: dict[int, int] = {}
-    dm_votes: dict[int, int] = {}
-
-    with Session(engine) as session:
-        stmt = (
-            select(CouncilMembers)
-            .where(CouncilMembers.ElectionCycle == get_election_name(config))
-            .filter(CouncilMembers.ClanLeaderSpeechId.is_not(None))
-        )
-
-        for nominee in sorted(
-            session.scalars(stmt),
-            key=lambda nominee: guild.get_member(nominee.MemberId).display_name,
-        ):
-            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_name(config))
-            .filter(CouncilMembers.DiscordManagerSpeechId.is_not(None))
-        )
-
-        for nominee in sorted(
-            session.scalars(stmt),
-            key=lambda nominee: guild.get_member(nominee.MemberId).display_name,
-        ):
-            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
+        votes_str += f"\n<@{user_id}>: "
 
+        for num in range(num_votes):
+            votes_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
-
-
-def record_event_participation(config: DakinyConfig, users: list[str], is_member: bool):
-    """
-    Adds participation points to all users listed. Checks if they don't exist in order to make a new entry, otherwise
-    adds points to the existing value.
-
-    Args:
-        config (DakinyConfig): Dakiny config for getting points
-        users (list[int]): users that participated and need points.
-        is_member (bool): whether the users are a discord member or not
-    """
-
-    cycle = get_quarter_name(config)
-    participation_point_value = config.params.event_participate_points
-    with Session(engine) as session:
-        for user in users:
-            stmt = (
-                select(ParticipationPoints)
-                .where(ParticipationPoints.UserId == user)
-                .where(ParticipationPoints.Cycle == cycle)
-            )
-
-            points = session.scalar(stmt)
-            if points is None:
-                new_points = ParticipationPoints(
-                    Cycle=cycle,
-                    UserId=user,
-                    DiscordMember=is_member,
-                    Points=participation_point_value,
-                )
-                session.add(new_points)
-            else:
-                points.Points += participation_point_value
-
-        session.commit()
-
-
-def record_event_host(config: DakinyConfig, user: int):
-    """
-    Adds host points to the given user. Checks if they don't exist in order to make a new entry, otherwise adds points
-    to the existing value.
-
-    Args:
-        config (DakinyConfig): Dakiny config for getting points
-        user (int): Id of user that hosted.
-    """
-    cycle = get_quarter_name(config)
-    host_point_value = config.params.event_host_points
-    with Session(engine) as session:
-        stmt = (
-            select(ParticipationPoints)
-            .where(ParticipationPoints.UserId == str(user))
-            .where(ParticipationPoints.Cycle == cycle)
-        )
-
-        points = session.scalar(stmt)
-        if points is None:
-            new_points = ParticipationPoints(
-                Cycle=cycle,
-                UserId=str(user),
-                DiscordMember=True,
-                Points=host_point_value,
-            )
-            session.add(new_points)
-        else:
-            points.Points += host_point_value
-
-        session.commit()
-
-
-async def update_clan_messages(guild: nextcord.Guild, channel_updates: Iterable[str]):
-    """
-    Updates all clan messages to contents in MESSAGES_DIR.
-    Does not to any git work. Is expected to be called after git is pulled.
-
-    for ever directory, sort the files by number then edits/sends the message.
-
-    Channel fetching/management is handled by another function.
-    Message editing and sending is handled by another function.
-
-    Args:
-        guild (nextcord.Guild): Guild object that all channels and messages belong to.
-    """
-
-    dirs = [
-        dir_name
-        for dir_name in channel_updates
-        if os.path.isdir(f"{MESSAGES_DIR}/{dir_name}")
-    ]
-
-    with Session(engine) as session:
-        for dir_name in dirs:
-            dir_path = f"{MESSAGES_DIR}/{dir_name}"
-            channel = await get_clan_message_channel(session, dir_name, guild)
-            sorted_files = sorted(
-                os.listdir(dir_path),
-                key=lambda filename: int(filename.split(".")[0]),
-            )
-
-            for file_name in sorted_files:
-                message_name = f"{dir_name}/{file_name}"
-                file_path = f"{dir_path}/{file_name}"
-                with open(file_path, "r", encoding="utf8") as reader:
-                    await edit_clan_message(
-                        session, channel, message_name, reader.read(2000)
-                    )
-
-
-async def get_clan_message_channel(
-    session: Session, channel_name: str, guild: nextcord.Guild
-) -> nextcord.TextChannel:
-    """
-    Used to obtain a channel from the guild object. Searches database for an id to get the channel. If that is not
-    found, then searches through all channels in the guild to find one with a matching name. If that also doesn't
-    turn up a channel, then creates it. Adds an entry into database for last two paths.
-    Assumes that there is an open session to the database.
-
-    Args:
-        session (Session): Open connection to database.
-        channel_name (str): Name of channel to obtain.
-        guild (nextcord.Guild): Guild object to get channel from.
-
-    Returns:
-        nextcord.TextChannel: Channel object with name channel_name.
-    """
-    stmt = select(Messages.Id).where(Messages.Path == channel_name)
-    channel_id = session.scalar(stmt)
-    if channel_id is None:
-        ret_channel = None
-        # channel is not tracked. see if it exists
-        channels = await guild.fetch_channels()
-        for channel in channels:
-            if (
-                channel.name == channel_name
-                and channel.__class__ is nextcord.TextChannel
-            ):
-                ret_channel = channel
-
-        if ret_channel is None:
-            # channel doesn't exist, we must create it
-            ret_channel = await guild.create_text_channel(
-                channel_name,
-                reason="Creating channel as required for by design of Dakiny-Messages repo.",
-            )
-
-        # record channel information
-        new_item = Messages(Path=channel_name, Id=ret_channel.id)
-        session.add(new_item)
-        session.commit()
-        return ret_channel
-
-    try:
-        return await guild.fetch_channel(channel_id)
-    except nextcord.NotFound:
-        # the channel was deleted for some reason
-        ret_channel = await guild.create_text_channel(
-            channel_name,
-            reason="Creating channel as required for by design of Dakiny-Messages repo.",
-        )
-        stmt = (
-            update(Messages)
-            .where(Messages.Path == channel_name)
-            .values(Id=ret_channel.id)
-        )
-        session.execute(stmt)
-        session.commit()
-        return ret_channel
-
-
-async def edit_clan_message(
-    session: Session,
-    channel: nextcord.TextChannel,
-    message_name: str,
-    message_content: str,
-):
-    """
-    Obtains a message id from database. If no id, then need to send a new message and record the id.
-    If there is a message, then edit the message. If that message is not found in discord, then need to
-    send a new message and record the id in the database.
-
-    Args:
-        session (Session): Open connection to database.
-        channel (nextcord.TextChannel): Channel object that message belongs to.
-        message_name (str): Name of the message. Corresponds to the file that contains message content.
-        message_content (str): Content of the message to edit/send.
-    """
-    stmt = select(Messages.Id).where(Messages.Path == message_name)
-    msg_id = session.scalar(stmt)
-    if msg_id is None:
-        # don't have a message for this file
-        msg = await channel.send(message_content)
-        new_message = Messages(Path=message_name, Id=msg.id)
-        session.add(new_message)
-        session.commit()
-    else:
-        try:
-            msg: nextcord.Message = await channel.fetch_message(msg_id)
-            await msg.edit(message_content)
-        except nextcord.NotFound:
-            msg = await channel.send(message_content)
-            stmt = (
-                update(Messages).where(Messages.Path == message_name).values(Id=msg.id)
-            )
-            session.execute(stmt)
-            session.commit()
-
-
-async def edit_clan_council_info(guild: nextcord.Guild, config: DakinyConfig):
-    """
-    Gets the winners of the elections and updates the perminant message that states the current council.
-
-    Args:
-        guild (nextcord.Guild): Guild object that to use to get channel.
-        config (DakinyConfig): Configs
-    """
-    clan_info_channel: nextcord.TextChannel = await guild.fetch_channel(
-        config.params.clan_info_channel_id
-    )
-
-    election = get_election_name(config)
-    with Session(engine) as session:
-        stmt = (
-            select(CouncilMembers.MemberId)
-            .where(CouncilMembers.ElectionCycle == election)
-            .where(CouncilMembers.DiscordManager == true())
-        )
-        discord_manager = session.scalar(stmt)
-        stmt = (
-            select(CouncilMembers.MemberId)
-            .where(CouncilMembers.ElectionCycle == election)
-            .where(CouncilMembers.ClanLeader == true())
-        )
-        clan_leader = session.scalar(stmt)
-        stmt = (
-            select(CouncilMembers.MemberId)
-            .where(CouncilMembers.ElectionCycle == election)
-            .where(CouncilMembers.Elected == true())
-        )
-
-        council_members_strs = [
-            f"<@{id}>"
-            for id in session.scalars(stmt)
-            if id not in (discord_manager, clan_leader)
-        ]
-
-        quarter = get_quarter_name(config)
-
-        with open(
-            f"{TEMPLATES_DIR}/council_members.txt", mode="r", encoding="utf8"
-        ) as file:
-            message = file.read()
-            message = message.format(
-                quarter=quarter,
-                council="\n".join(council_members_strs),
-                clan_leader=clan_leader,
-                discord_manager=discord_manager,
-            )
-
-        await edit_clan_message(
-            session, clan_info_channel, "council_members.txt", message
-        )
+    return votes_str