Process voting end.

Give the elect role and set elected in database.

.gitea/workflows/build_develop.yml

@@ -1,6 +1,10 @@
 name: build_develop
 
-on: [push]
+on: 
+  push:
+    branches:
+      - '*'
+      - '!main'
 
 jobs:
   build:
@@ -12,7 +16,15 @@ jobs:
           fetch-depth: 0
       - name: Install Docker
         uses: https://github.com/papodaca/install-docker-action@v1
+      - name: Log into container registry
+        uses: docker/login-action@v2
+        with:
+          registry: gitea.cheezers.org
+          username: imcompiling
+          password: ${{ secrets.PASSWORD }}
+      - name: set env
+        run: echo "GIT_BRANCH=${GITHUB_HEAD_REF:-${GITHUB_REF#refs/heads/}}" >> $GITHUB_ENV
       - name: Build Docker Image
-        run: docker build -t gitea.cheezers.org/imcompiling/dakiny-bot:develop .
+        run: docker build -t gitea.cheezers.org/imcompiling/dakiny-bot:${{env.GIT_BRANCH}} .
       - name: Push Docker Image
-        run: docker push gitea.cheezers.org/imcompiling/dakiny-bot:develop
+        run: docker push gitea.cheezers.org/imcompiling/dakiny-bot:${{env.GIT_BRANCH}}

.gitea/workflows/build_latest.yml

@@ -14,6 +14,12 @@ jobs:
           fetch-depth: 0
       - name: Install Docker
         uses: https://github.com/papodaca/install-docker-action@v1
+      - name: Log into container registry
+        uses: docker/login-action@v2
+        with:
+          registry: gitea.cheezers.org
+          username: imcompiling
+          password: ${{ secrets.PASSWORD }}
       - name: Build Docker Image
         run: docker build -t gitea.cheezers.org/imcompiling/dakiny-bot:latest .
       - name: Push Docker Image

.gitea/workflows/build_release.yml

@@ -0,0 +1,28 @@
+name: build_release
+
+on:
+  push:
+    tags: ["v[0-9].[0-9].[0-9]"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Install Docker
+        uses: https://github.com/papodaca/install-docker-action@v1
+      - name: Log into container registry
+        uses: docker/login-action@v2
+        with:
+          registry: gitea.cheezers.org
+          username: imcompiling
+          password: ${{ secrets.PASSWORD }}
+      - name: Set env
+        run: echo "GIT_TAG=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
+      - name: Build Docker Image
+        run: docker build -t gitea.cheezers.org/imcompiling/dakiny-bot:${{env.GIT_TAG}} .
+      - name: Push Tagged Image
+        run: docker push gitea.cheezers.org/imcompiling/dakiny-bot:${{env.GIT_TAG}}

.gitignore

@@ -139,4 +139,4 @@ TODO.txt
 sql_tester.py
 conf
 outputs
-dakiny.db
+database

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.8.10-slim
+FROM python:3.10.6-slim
 
 # install dependencies for mysqlclient
 # RUN apt-get update && apt-get -y upgrade && apt-get -y install python3-dev default-libmysqlclient-dev build-essential
@@ -7,11 +7,16 @@ RUN pip install --upgrade pip
 
 WORKDIR /home
 
-COPY cogs cogs/
-COPY dakiny_bot.py dakiny_bot.py
 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 -r requirements.txt
 

README.md

@@ -1,50 +1,5 @@
-# Discord Bot Template
+# Dakiny Bot
 
-[![Discord](https://img.shields.io/discord/819650821314052106?color=7289DA&logo=discord&logoColor=white)](https://discord.gg/fPrdqh3Zfu "Dev Pro Tips Discussion & Support Server")
+Bot assumes that it always did the step before it. If the step before an action didn't happen, behavior is undefined.
-[![Powered by Nextcord](https://custom-icon-badges.herokuapp.com/badge/-Powered%20by%20Nextcord-0d1620?logo=nextcord)](https://github.com/nextcord/nextcord "Powered by Nextcord Python API Wrapper")
+Object creation in the middle of a cycle is only there for restarting the bot. All relevant information should already
-
+exist in the database.
-This repo is a template for easy creation of maintainable Python Discord bots.
-
-The library used is [Nextcord](https://github.com/nextcord/nextcord), a maintained fork of Discord.py.
-
-Nextcord documentation: https://nextcord.readthedocs.io/en/latest/
-
-📺 Python Discord Tutorial: https://www.youtube.com/playlist?list=PL9YUC9AZJGFG6larkQJYio_f0V-O1NRjy
-
-## How to use
-
-Click "use this template" at the top of this repo and follow the instructions, or alternatively, initialize a git repo and copy the template files into the directory.
-
-```bash
-# Create a new folder (replace my-discord-bot with your bot's name)
-mkdir my-discord-bot && cd my-discord-bot
-# Initialize the folder as a git repository and copy the template files
-git init
-cp ../discord-bot-template/* .
-```
-
-## Environment variables
-
-To run your bot, you'll need a token and other secrets set in a `.env` file.
-
-Create a file called `.env` and place it in the root of your project.
-
-(You can do this by creating a copy of `.env.sample` and renaming it to `.env`)
-
-The contents should look something like this (where the part after `=` is the token you received from the Discord Developer Portal)
-
-```
-DISCORD_TOKEN=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-```
-
-If you require additional API keys or variables specific to an enviroment, they should also be added here. You can access them by adding a line such as `GUILD_ID = os.getenv("GUILD_ID", "")` to `config.py`.
-
-## Heroku
-
-`runtime.txt` and `Procfile` are used for Heroku configuration and can be deleted in case you do not plan on hosting there.
-
-Heroku setup tutorial: https://www.youtube.com/watch?v=EreE-0hQibM
-
-## IDE Configuration
-
-IDE config such as the `.vscode` folder do not normally belong on GitHub since they are often specific to a particular environment. To make sure GitHub will ignore the `.vscode` folder uncomment the line at the end of the `.gitignore`.

bot_messages/election_announcement.txt

@@ -34,16 +34,16 @@ The Clan Council will be denoted by the Discord ranks of <@&{clan_council_id}> a
 <:Rank_Owner:479008325137072155> Clan Leader
 ---message_break---
 __Here's the timeline:__
-Election begins: {election_start_date}
+Election begins: {election_start}
-Term: {term_start_date} - {term_end_date}
+Term: {term_start} - {term_end}
 
-**{election_start_date}**: Post here to announce candidacy
+**{election_start}**: Post here to announce candidacy
-**{voting_start_date}**: Voting begins
+**{voting_start}**: Voting begins
-**{voting_end_date}**: Votes are tallied and winners are announced
+**{voting_end}**: Votes are tallied and winners are announced
-**{highcouncil_election_date}**: The new Clan Council votes who among them shall receive the two High Council positions of: Clan Leader and Discord Server Manager.
+**{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_date}**: The new Clan Council is officially inaugurated and a drop party (or a giveaway event) begins to commemorate the new leadership.
+**{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_date} with the inauguration scheduled for {term_end_date}.
+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!
 **

bot_messages/highcouncil_election.txt

@@ -8,6 +8,6 @@ From {highcouncil_election_announce} to {highcouncil_election_start}, you will b
  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 apply to all candidates of that category.
+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 the {highcouncil_election_end}, so we can announce and have everyone set up to start the term by {term_start}
+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

@@ -1,8 +1,8 @@
 ====================
 <@&{clan_member_id}>, it's time to vote for clan council.
 
-React with <{voting_emote_id}> to vote.
+Press the Vote button to vote!
-Voting ends next {voting_end_day}, {voting_end_date}.
+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.

classes/election_cycle.py

@@ -2,15 +2,18 @@
 Contains the election cycle class
 """
 
-from datetime import datetime, timedelta
+import collections
+from datetime import datetime
 
 import nextcord
-from nextcord.ext import commands
+from sqlalchemy import select
 from sqlalchemy.orm import Session
 
+from classes.nominate_views import NominateView
+from classes.voting_views import VoteView
 from config import DakinyConfig
-from database.sql_data_classes import ElectionInformation, engine
+from database_setup.sql_data_classes import CouncilMembers, ElectionInformation, Votes, engine
-from utils import get_datetime
+from utils import build_votes_str, get_datetime, get_election_cycle_name
 
 
 class ElectionCycle:
@@ -19,28 +22,29 @@ class ElectionCycle:
     the cycle.
     """
 
-    def __init__(self, cycle: int, bot) -> None:
+    def __init__(self, cycle: int, config: DakinyConfig, guild: nextcord.Guild) -> None:
         """
-        Generates all dates relevant to the election cycle from input election start, term start and end dates.
+        Generates all dates relevant to the election cycle determined by the config and cycle.
 
         Args:
-            election_start (datetime): Date the election cycle starts.
+            cycle (int): Which election cycle this cycle is.
-            term_start (datetime): Date the term being elected starts.
+            config (DakinyConfig): The entire config object.
-            term_end (datetime): Date the term being elected ends.
+            guild (nextcord.Guild): The guild that this election is running in.
-            bot: the discord bot instance
         """
-        self.config: DakinyConfig = bot.config
+
+        self.config: DakinyConfig = config
         self.cycle = cycle
-        self.elecion_cycle = self.config.election_cycles[self.cycle]
+        self.election_cycle = self.config.election_cycles[self.cycle]
-        self.election_start: datetime = get_datetime(self.elecion_cycle.election_start)
+        self.election_start: datetime = get_datetime(self.election_cycle.election_start)
-        self.term_start: datetime = get_datetime(self.elecion_cycle.term_start)
+        self.term_start: datetime = get_datetime(self.election_cycle.term_start)
-        self.term_end: datetime = get_datetime(self.elecion_cycle.term_end)
+        self.term_end: datetime = get_datetime(self.election_cycle.term_end)
-        self.voting_start: datetime = get_datetime(self.elecion_cycle.voting_start)
+        self.voting_start: datetime = get_datetime(self.election_cycle.voting_start)
-        self.voting_end: datetime = get_datetime(self.elecion_cycle.voting_end)
+        self.voting_end: datetime = get_datetime(self.election_cycle.voting_end)
-        self.highcouncil_election_announce: datetime = self.voting_end + timedelta(days=1)
+        self.highcouncil_election_announce: datetime = get_datetime(self.election_cycle.highcouncil_election_announce)
-        self.highcouncil_election_start: datetime = self.highcouncil_election_announce + timedelta(days=3)
+        self.highcouncil_election_start: datetime = get_datetime(self.election_cycle.highcouncil_election_start)
-        self.highcouncil_election_end: datetime = self.term_start - timedelta(days=1)
+        self.highcouncil_election_end: datetime = get_datetime(self.election_cycle.highcouncil_election_end)
-        self.bot: commands.Bot = bot
+        self.guild: nextcord.Guild = guild
+        self.election_over: bool = False
 
     def build_election_announcement(self) -> list[str]:
         """
@@ -54,23 +58,25 @@ class ElectionCycle:
         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) % 4].election_start)
+            next_election = get_datetime(
+                self.config.election_cycles[(self.cycle + 1) % len(self.config.election_cycles)].election_start
+            )
 
             message = message.format(
                 clan_council_id=self.config.params.clan_council_role_id,
                 high_council_id=self.config.params.high_council_role_id,
-                election_start_date=self.election_start.strftime("%B %d"),
+                election_start=self.election_start.strftime("%B %d"),
-                term_start_date=self.term_start.strftime("%B %d"),
+                term_start=self.term_start.strftime("%B %d"),
-                term_end_date=self.term_end.strftime("%B %d"),
+                term_end=self.term_end.strftime("%B %d"),
-                voting_start_date=self.voting_start.strftime("%B %d"),
+                voting_start=self.voting_start.strftime("%B %d"),
-                voting_end_date=self.voting_end.strftime("%B %d"),
+                voting_end=self.voting_end.strftime("%B %d"),
-                highcouncil_election_date=self.highcouncil_election_start.strftime("%B %d"),
+                highcouncil_election=self.highcouncil_election_start.strftime("%B %d"),
-                next_election_start_date=next_election.strftime("%B %d"),
+                next_election_start=next_election.strftime("%B %d"),
             )
 
             return message.split("---message_break---")
 
-    def build_highcouncil_election(self) -> str:
+    def build_highcouncil_election_announce(self) -> str:
         """
         Builds message to announce highcouncil election start.
 
@@ -81,7 +87,29 @@ class ElectionCycle:
         with open("bot_messages/highcouncil_election.txt", mode="r", encoding="utf8") as file:
             message = file.read()
 
-            return message.format()
+            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"),
+                term_start=self.term_start.strftime("%B %d"),
+            )
+
+    def build_highcouncil_vote_start(self) -> str:
+        """
+        Builds the message to announce that highcouncil voting has started.
+
+        Returns:
+            str: Message to send.
+        """
+
+        with open("bot_messages/highcouncil_vote.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,
+                term_start=self.term_start.strftime("%B %d"),
+            )
 
     def build_vote_start(self) -> str:
         """
@@ -97,8 +125,7 @@ class ElectionCycle:
 
             return message.format(
                 clan_member_id=self.config.params.clan_member_role_id,
-                voting_emote_id=self.config.params.voting_emote_id,
+                voting_end=vote_end.strftime("%B %d"),
-                voting_end_date=vote_end.strftime("%B %d"),
                 voting_end_day=vote_end.strftime("%A"),
             )
 
@@ -112,26 +139,26 @@ class ElectionCycle:
         if today.date() == self.election_start.date():
             await self.election_start_action()
         elif today.date() == self.voting_start.date():
-            await self.voting_end_action()
+            await self.voting_start_action()
         elif today.date() == self.voting_end.date():
             await self.voting_end_action()
         elif today.date() == self.highcouncil_election_start.date():
-            await self.highcouncil_election_action()
+            await self.highcouncil_election_start_action()
         elif today.date() == self.term_start.date():
             await self.term_start_action()
-        elif today.date() == self.term_end.date():
-            await self.term_end_action()
 
     async def election_start_action(self) -> None:
         """
         Performs required actions for when the election cycle starts.
         """
         # create new channel for election
-        category: nextcord.CategoryChannel = self.bot.get_channel(self.config.params.active_category_id)
+        category: nextcord.CategoryChannel = self.guild.get_channel(self.config.params.active_category_id)
-        quarter_name: str = self.get_election_cycle_name()
+        quarter_name: str = get_election_cycle_name(self.config)
 
         # create new entry into database.
-        election_channel = await category.create_text_channel(quarter_name)
+        election_channel: nextcord.TextChannel = await category.create_text_channel(quarter_name)
+        clan_member_role: nextcord.Role = self.guild.get_role(self.config.params.clan_member_role_id)
+        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)
@@ -141,53 +168,108 @@ class ElectionCycle:
         # election start message is returned as an array of string because it is too long. send each string
         # individually.
         messages = self.build_election_announcement()
-        for message in messages:
+        for index, message in enumerate(messages):
+            # if last item, add the nominate button
+            if index + 1 == len(messages):
+                await election_channel.send(message, view=NominateView(self.config))
+            else:
                 await election_channel.send(message)
 
     async def voting_start_action(self) -> None:
         """
-        Performs required actions for when voting for candidates starts.
+        Sends message informing members that voting has started.
+        Removes write permission from the general clan member role.
         """
-        print("Voting has started")
+        message = self.build_vote_start()
-        await self.message_me("Voting has started")
+        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_cycle_name(self.config)
+            )
+            info = session.scalar(stmt)
+            info.CouncilVoteMsgId = vote_msg.id
+            session.commit()
+
+        await election_channel.set_permissions(clan_member_role, send_messages=False)
 
     async def voting_end_action(self) -> None:
         """
         Performs required actions for when voting time has ended.
         """
-        print("voting has ended")
-        await self.message_me("voting has ended")
 
-    async def highcouncil_election_action(self) -> None:
+        message = self.build_highcouncil_election_announce()
+        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:
+            stmt = select(ElectionInformation.CouncilVoteMsgId).where(
+                ElectionInformation.ElectionCycle == election_name
+            )
+            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 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:
+                    stmt = (
+                        select(CouncilMembers)
+                        .where(CouncilMembers.ElectionCycle == election_name)
+                        .where(CouncilMembers.MemberId == user_id)
+                    )
+                    council_member = session.scalar(stmt)
+                    council_member.Elected = True
+                    session.commit()
+
+                    user: nextcord.Member = self.guild.get_member(user_id)
+
+                    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:
         """
         Performs required actions for when the highcouncil is elected.
         """
-        print("Highcouncil election has started.")
+
-        await self.message_me("Highcouncil election has started.")
+        message = self.build_highcouncil_vote_start()
+        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:
-        msg: str = "the term has started"
-        print(msg)
-        self.message_me(msg)
-
-    async def term_end_action(self):
-        msg: str = "the term has ended"
-        print(msg)
-        self.message_me(msg)
-
-    async def message_me(self, msg: str):
         """
-        message a string to me
+        Moves the election channel into the archive category.
         """
-        imcompiling: nextcord.User = await self.bot.fetch_user(206602713511886849)
-        await imcompiling.send(msg)
 
-    def get_election_cycle_name(self) -> str:
+        self.election_over = True
+        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+        archive: nextcord.CategoryChannel = self.guild.get_channel(self.config.params.archive_channel_group_id)
+
+        await election_channel.move(beginning=True, category=archive)
+
+    def get_election_info(self) -> ElectionInformation:
         """
-        Builds the unique name of the current election cycle
+        Gets information for current election.
 
         Returns:
-            str: the name of the election cycle
+            ElectionInformation: The information from the database about the current election.
         """
 
-        return f"{self.election_start.year} {self.elecion_cycle.name} election"
+        with Session(engine) as session:
+            stmt = select(ElectionInformation).where(
+                ElectionInformation.ElectionCycle == get_election_cycle_name(self.config)
+            )
+            return session.scalar(stmt)

classes/nominate_views.py

@@ -0,0 +1,133 @@
+"""
+Contains various views to be used in the 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 get_election_cycle_name
+
+NOMINEE_SPLITTER = "========================================================\n\n"
+
+
+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):
+        super().__init__(
+            "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_nomination(interaction.user.id, self.speech.value)
+
+        with Session(engine) as session:
+            if not self.usr_nominated:
+                msg = await interaction.channel.send(speech)
+
+                council_member = CouncilMembers(
+                    ElectionCycle=get_election_cycle_name(self.config),
+                    MemberId=interaction.user.id,
+                    SpeechMsgId=msg.id,
+                )
+                session.add(council_member)
+                session.commit()
+            else:
+                # user already nominated, just need to update the election speech
+                cycle = get_election_cycle_name(self.config)
+                stmt = (
+                    select(CouncilMembers)
+                    .where(CouncilMembers.ElectionCycle == cycle)
+                    .where(CouncilMembers.MemberId == self.usr_id)
+                )
+                obj = session.scalar(stmt)
+                obj.SpeechMsgContents = self.speech.value
+
+                msg: nextcord.Message = await interaction.channel.fetch_message(obj.SpeechMsgId)
+                await msg.edit(content=decorate_nomination(interaction.user.id, self.speech.value))
+
+
+class NominateView(nextcord.ui.View):
+    """
+    The button to press to start your nomination.
+    """
+
+    def __init__(self, config):
+        super().__init__(timeout=None)
+        self.config: DakinyConfig = config
+
+    @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.
+
+        Args:
+            button (nextcord.ui.Button): Unused. idk why its needed in the decorator
+            interaction (nextcord.Interaction): Interaction of user who pressed the button
+        """
+
+        cycle = get_election_cycle_name(self.config)
+        usr_nominated = False
+        speech_content = ""
+        with Session(engine) as session:
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionCycle == cycle)
+                .where(CouncilMembers.MemberId == interaction.user.id)
+            )
+            obj = session.scalar(stmt)
+            if obj is not None:
+                usr_nominated = True
+                msg = await interaction.channel.fetch_message(obj.SpeechMsgId)
+                speech_content = msg.content.split(NOMINEE_SPLITTER)[1]
+
+        await interaction.response.send_modal(
+            NominateModal(self.config, interaction.user.id, usr_nominated, speech_content)
+        )
+
+
+def decorate_nomination(user_id, speech) -> str:
+    """
+    Decorates a nomination speech so that it sits within multiple speeches better.
+
+    Args:
+        user_id (_type_): ID of user sending the speech
+        speech (_type_): Speech from the user
+
+    Returns:
+        str: Decorated speech
+    """
+    msg = f"**Clan Council Nominee: <@{user_id}>**\n"
+    msg += NOMINEE_SPLITTER
+    msg += speech
+
+    return msg

classes/voting_views.py

@@ -0,0 +1,127 @@
+"""
+Contains various views to be used while voting. 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
+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_cycle_name
+
+
+class VoteSelect(nextcord.ui.StringSelect):
+    def __init__(self, options: List["SelectOption"], config: DakinyConfig) -> None:
+        super().__init__(
+            placeholder="Choose 1",
+            min_values=1,
+            max_values=1,
+            options=options,
+        )
+        self.config = config
+
+    async def callback(self, interaction: Interaction):
+        election_name = get_election_cycle_name(self.config)
+        with Session(engine) as session:
+            stmt = select(ElectionInformation.CouncilVoteMsgId).where(
+                ElectionInformation.ElectionCycle == election_name
+            )
+            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 = (
+                    select(Votes)
+                    .where(Votes.ElectionCycle == election_name)
+                    .where(Votes.VoterId == interaction.user.id)
+                )
+                vote = session.scalar(stmt)
+                vote.VotedForId = voted_for
+                session.commit()
+
+        vote_message_str = build_votes_str(self.config)
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(vote_msg_id)
+        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 VoteView(nextcord.ui.View):
+    """
+    The button to press to start your nomination.
+    """
+
+    def __init__(self, config: DakinyConfig, guild: nextcord.Guild):
+        super().__init__(timeout=None)
+        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:
+        """
+        TODO
+
+        Args:
+            button (nextcord.ui.Button): Unused. idk why its needed in the decorator
+            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
+
+        election: str = get_election_cycle_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 == election)
+
+            options = [
+                SelectOption(
+                    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 session.scalars(stmt)
+            ]
+            options.append(SelectOption(label="Abstain ☑️" if voted_for is None else "Abstain", value="Abstain"))
+
+        view = nextcord.ui.View()
+        view.add_item(VoteSelect(options=options, config=self.config))
+
+        await interaction.response.send_message(
+            content="Please vote for a clan member!",
+            view=view,
+            ephemeral=True,
+        )

cogs/commands/__init__.py

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

cogs/commands/request.py

@@ -0,0 +1,103 @@
+"""
+Contains commands and views for request commands.
+"""
+
+import nextcord
+from nextcord.ext import commands
+
+from config import DakinyConfig
+
+
+class RequestCog(commands.Cog, name="Request Commands"):
+    """
+    Class holds request commands.
+    """
+
+    def __init__(self, bot) -> None:
+        """
+        Default constructor for RequestCog class. Does nothing.
+        """
+        self.bot: commands.Bot = bot
+
+    @nextcord.slash_command()
+    async def request(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for help. Never called.
+        """
+
+    @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."
+        ),
+    ):
+        """
+        Sends a message to admins to request a nickname change.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            new_username(str): The username to change to.
+        """
+
+        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)
+
+
+class UsernameRequest(nextcord.ui.View):
+    """
+    View provides approve and deny buttons and action for a username change request.
+    """
+
+    def __init__(self, user_id: int, new_nickname: str, *, timeout: float | None = 180, auto_defer: bool = True):
+        super().__init__(timeout=timeout, auto_defer=auto_defer)
+        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):
+        """
+        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.
+        Removes the view from the interaction message.
+
+        Args:
+            button (nextcord.ui.Button): Unused.
+            interaction (nextcord.Interaction): The interaction of the user clicking the button.
+        """
+        user = interaction.guild.get_member(self.user_id)
+        if user is not None:
+            try:
+                await user.edit(nick=self.new_nickname)
+                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(
+                    content="Please change manually.",
+                    ephemeral=True,
+                )
+                content = (
+                    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)
+        else:
+            await interaction.response.edit_message(
+                content="An error occured while changing the user's nickname.", 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 nickname 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

@@ -0,0 +1,85 @@
+"""
+Contains commands and views for set commands.
+"""
+
+from datetime import datetime
+
+import nextcord
+from nextcord.ext import commands
+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
+
+
+class setCog(commands.Cog, name="Set Commands"):
+    """
+    Class holds set commands.
+    """
+
+    def __init__(self) -> None:
+        """
+        Default constructor for SetCog class. Does nothing.
+        """
+
+    @nextcord.slash_command()
+    async def set(self, interaction: nextcord.Interaction):
+        """
+        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.")
+    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."),
+    ):
+        """
+        Sets a user's birthday in the database. Removes on input 0/0. If birthday is today, adds to the birthday_list.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            month (int, optional): The month a user was born. Is SlashOption.
+            day (int, optional): The day a user was born. Is SlashOption.
+        """
+
+        # Must be deferred, apparently datetime takes a little bit on invalid dates.
+        await interaction.response.defer(ephemeral=True)
+
+        if month == 0 and day == 0:
+            stmt = delete(UserBirthday).where(UserBirthday.UserId == interaction.user.id)
+            with Session(engine) as session:
+                session.execute(stmt)
+                session.commit()
+                await interaction.followup.send("Removed birthday.", ephemeral=True)
+                return
+
+        # check if valid day
+        today = datetime.today()
+        try:
+            birthday = datetime(today.year, month, day)
+        except ValueError:
+            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}")
+        with Session(engine) as session:
+            try:
+                session.add(new_birthday)
+                session.commit()
+            except IntegrityError:
+                # User already has birthday, change it instead.
+                session.rollback()
+                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)

cogs/commands/test.py

@@ -3,9 +3,11 @@ Commands for testing.
 """
 
 import nextcord
-from nextcord.ext import commands
+from nextcord.ext import application_checks, commands
 
 from classes.election_cycle import ElectionCycle
+from config import DakinyConfig
+from utils import get_current_cycle
 
 
 class TestCog(commands.Cog, name="Test commands."):
@@ -19,7 +21,14 @@ class TestCog(commands.Cog, name="Test commands."):
         """
         self.bot = bot
 
+    def is_me():
+        def predicate(interaction: nextcord.Interaction):
+            return interaction.user.id == 206602713511886849
+
+        return application_checks.check(predicate)
+
     @nextcord.slash_command()
+    @is_me()
     async def test(self, interaction: nextcord.Interaction):
         """
         Parent slash command for help. Never called.
@@ -51,5 +60,30 @@ class TestCog(commands.Cog, name="Test commands."):
             interaction (nextcord.Interaction): _description_
         """
 
-        cycle = ElectionCycle(0, self.bot)
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(get_current_cycle(config), config, self.bot.get_guild(config.params.guild_id))
         await cycle.election_start_action()
+
+    @test.subcommand()
+    async def voting_start(self, interaction: nextcord.Interaction):
+        """
+        tests the voting start action
+
+        Args:
+            interaction (nextcord.Interaction): _description_
+        """
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(get_current_cycle(config), config, self.bot.get_guild(config.params.guild_id))
+        await cycle.voting_start_action()
+
+    @test.subcommand()
+    async def voting_end(self, interaction: nextcord.Interaction):
+        """
+        tests the voting start action
+
+        Args:
+            interaction (nextcord.Interaction): _description_
+        """
+        config: DakinyConfig = self.bot.config
+        cycle = ElectionCycle(get_current_cycle(config), config, self.bot.get_guild(config.params.guild_id))
+        await cycle.voting_end_action()

cogs/loops/daily_loop.py

@@ -1,13 +1,21 @@
 """
-_summary_
+Defines the daily loop that runs the Dakiny bot functions.
 """
 
-from datetime import time
+import random
+from datetime import datetime, time
 
+import nextcord
 from nextcord.ext import commands, tasks
 from pytz import timezone
+from sqlalchemy import select
+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 utils import get_current_cycle
 
 
 class DailyLoop(commands.Cog, name="Daily Loop"):
@@ -17,21 +25,96 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
 
     def __init__(self, bot: commands.Bot) -> None:
         self.bot = bot
-        # TODO need to figure out how to determine the current cycle
+        self.current_election = None
-        self.current_election = ElectionCycle(0, self.bot)
+        self.update_birthdays()
 
-    @commands.Cog.listener()
+        # pylint doesn't recognize that daily_loop is subclassed from tasks.loop.
-    async def on_ready(self):
+        self.daily_loop.start()  # pylint: disable=no-member
-        """
-        Starts the loop when bot is ready.
-        """
-        await self.bot.wait_until_ready()
-        # pylint doesn't recognize that periodic_update_guild_data is subclassed from tasks.loop.
-        await self.do_thing.start()  # pylint: disable=no-member
 
     @tasks.loop(time=time(hour=0, tzinfo=timezone("GMT")))
-    async def do_thing(self):
+    async def daily_loop(self):
-        """ """
+        """
-        print("loop")
+        Runs daily. Checks if the current election is None. If so, checks if there is an active election. If there is
+        an active election, runs the check_date() function for the election to perform actions. Finally checks if the
+        election is over to delete the current election object.
+        """
+
+        if self.current_election is None:
+            self.current_election = self.get_election_cycle()
+
+        if self.current_election is not None:
             await self.current_election.check_date()
-        # TODO need to figure out how to change the election cycle after current one is over
+            if self.current_election.election_over:
+                self.current_election = None
+
+        self.update_birthdays()
+
+        if 239547993106284544 in birthday_list:
+            # inform kandy that it is her "birthday"
+            kandy: nextcord.User = await self.bot.fetch_user(239547993106284544)
+            await kandy.send('Happy "Birthday"!')
+
+        await self.cakedays()
+
+    @daily_loop.before_loop
+    async def before_loop(self):
+        """
+        Actions run before the loop starts. Want to wait for bot to be ready and get the current cycle.
+        """
+
+        await self.bot.wait_until_ready()
+
+        # Bot needs to know guilds to get the current cycle.
+        self.current_election = self.get_election_cycle()
+
+    def get_election_cycle(self) -> ElectionCycle:
+        """
+        Creates an object for the current election cycle if one is active. An election is considered active
+        between the election start and the term start.
+
+        Returns:
+            ElectionCycle: Current election cycle, None if there is no election happening.
+        """
+
+        config: DakinyConfig = self.bot.config
+        cycle = get_current_cycle(config)
+
+        return ElectionCycle(cycle, config, self.bot.get_guild(config.params.guild_id))
+
+    def update_birthdays(self) -> None:
+        """
+        Goes through database to collect all birthdays that are today. Adds user's id to birthday list.
+        """
+        birthday_list.clear()
+
+        # kandy's 1% chance
+        if random.randint(0, 99) == 0:
+            birthday_list.append(239547993106284544)
+
+        today = datetime.today()
+        birthday = f"{today.month}/{today.day}"
+
+        stmt = select(UserBirthday.UserId).where(UserBirthday.Birthday == birthday)
+        with Session(engine) as session:
+            to_add = session.scalars(stmt)
+            birthday_list.extend(to_add.all())
+
+    async def cakedays(self) -> None:
+        """
+        Loops through the guild's humans checking for joined_at dates that match today's date. Sends a message
+        saying happy cakeday.
+        """
+
+        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)
+
+        cakedays: list[nextcord.Member] = [
+            human for human in guild.humans if human.joined_at.month == today.month and human.joined_at.day == today.day
+        ]
+
+        for member in cakedays:
+            years = today.year - member.joined_at.year
+            year_str = "years" if years > 1 else "year"
+            msg = f"Happy Cake day! <@{member.id}> joined the discord {years} {year_str} ago!"
+            await announce_channel.send(msg)

cogs/message_listener/__init__.py

@@ -0,0 +1,43 @@
+"""
+Defines cog for on message listener.
+"""
+
+import nextcord
+from nextcord.ext import commands
+
+from dakiny_bot import birthday_list
+
+
+class SubmissionListener(commands.Cog, name="Message Listener"):
+    """Sets up message listener."""
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_message(self, message: nextcord.Message):
+        """Listener for message creation. Adds score and attachments to submission."""
+        # don't want to process any messages from bot.
+        if message.author.id == self.bot.user.id:
+            return
+
+        await birthday_action(message)
+
+
+# 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(SubmissionListener(bot))
+
+
+async def birthday_action(message: nextcord.Message) -> None:
+    """
+    Checks a message's auther and mentions to see if they are in the birthday list.
+
+    Args:
+        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)):
+        await message.add_reaction("🎂")

config.py

@@ -11,15 +11,17 @@ class Params:
     """
 
     active_category_id: int
-    annoucement_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
+    general_channel_id: int
+    guild_id: int
     high_council_role_id: int
-    voting_emote_id: str
 
 
 @dataclass
@@ -29,6 +31,9 @@ class ElectionCycle:
     """
 
     election_start: str
+    highcouncil_election_announce: str
+    highcouncil_election_end: str
+    highcouncil_election_start: str
     name: str
     term_end: str
     term_start: str

dakiny_bot.py

@@ -1,3 +1,4 @@
+import logging
 import os
 import sys
 
@@ -6,12 +7,22 @@ import nextcord
 from hydra.core.config_store import ConfigStore
 from nextcord.ext import commands
 
-import database.create_database as create_database
+import database_setup.create_database as create_database
+from classes.nominate_views import NominateView
+from classes.voting_views import VoteView
 from config import DakinyConfig
 
 cs = ConfigStore.instance()
 cs.store(name="dakiny_config", node=DakinyConfig)
 
+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"))
+logger.addHandler(handler)
+
 
 @hydra.main(config_path="conf", config_name="config")
 def main(cfg: DakinyConfig):
@@ -26,7 +37,7 @@ def main(cfg: DakinyConfig):
     # intents.guilds = True
 
     # To enable the members priveleged intent:
-    # intents.members = True
+    intents.members = True
 
     bot = commands.Bot(intents=intents)
     bot.config = cfg
@@ -40,6 +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.add_view(VoteView(cfg, bot.get_guild(cfg.params.guild_id)))
         print(f"{bot.user.name} has connected to Discord!")
 
     # Run Discord bot
@@ -48,4 +61,6 @@ def main(cfg: DakinyConfig):
 
 if __name__ == "__main__":
     sys.argv.append("hydra.job.chdir=False")
-    main()
+    sys.argv.append("hydra/job_logging=none")
+    sys.argv.append("hydra/hydra_logging=none")
+    main()  # pylint: disable=no-value-for-parameter

database_setup/create_database.py

@@ -5,11 +5,11 @@ Small script to create the database if it doesn't already exist.
 import sqlite3
 from os.path import exists
 
-if not exists("dakiny.db"):
+if not exists("database/dakiny.db"):
-    with sqlite3.connect("dakiny.db") as con:
+    with sqlite3.connect("database/dakiny.db") as con:
         cur = con.cursor()
 
-        with open("database/database.sql", mode="r", encoding="utf-8") as file:
+        with open("database_setup/database.sql", mode="r", encoding="utf-8") as file:
             database_script = file.read()
             cur.executescript(database_script)
             con.commit()

database_setup/database.sql

@@ -1,15 +1,14 @@
--- CREATE DATABASE dakiny;
--- use dakiny;
-
 CREATE TABLE ElectionInformation(
     ElectionCycle varchar(30) not null unique,
     ElectionChannel bigint unsigned not null,
+    CouncilVoteMsgId bigint unsigned,
     PRIMARY KEY (ElectionCycle)
 );
 
 CREATE TABLE CouncilMembers(
-    ElectionCycle varchar(30) not null unique,
+    ElectionCycle varchar(30) not null,
     MemberId bigint unsigned not null,
+    SpeechMsgId bigint unsigned  not null,
     Elected boolean DEFAULT false,
     HighCouncilElect boolean DEFAULT false,
     DiscordManager boolean DEFAULT false,
@@ -19,9 +18,15 @@ CREATE TABLE CouncilMembers(
 );
 
 CREATE TABLE Votes(
-    ElectionCycle varchar(30) not null unique,
+    ElectionCycle varchar(30) not null,
     VoterId bigint unsigned not null,
-    VotedForId bigint unsigned not null,
+    VotedForId bigint unsigned,
     FOREIGN KEY (ElectionCycle) REFERENCES ElectionInformation(ElectionCycle),
     PRIMARY KEY (ElectionCycle, VoterId)
 );
+
+CREATE TABLE UserBirthday (
+    UserId bigint unsigned not null,
+    Birthday varchar(5) not null,
+    PRIMARY KEY (UserId)
+);

database_setup/sql_data_classes.py

@@ -5,7 +5,7 @@ from sqlalchemy import create_engine
 from sqlalchemy.ext.automap import automap_base
 
 # connect with sql alchemy and autoload schema
-URL = "sqlite+pysqlite:///dakiny.db"
+URL = "sqlite+pysqlite:///database/dakiny.db"
 engine = create_engine(URL)
 Base = automap_base()
 Base.prepare(autoload_with=engine)
@@ -14,3 +14,4 @@ Base.prepare(autoload_with=engine)
 ElectionInformation = Base.classes.ElectionInformation
 CouncilMembers = Base.classes.CouncilMembers
 Votes = Base.classes.Votes
+UserBirthday = Base.classes.UserBirthday

permissions_required.txt

@@ -1,3 +1,6 @@
 Discord permissions required for bot to operate:
 
 manage channels
+manage roles
+manage nicknames
+need member intent

utils.py

@@ -4,6 +4,12 @@ File contains util functions.
 
 from datetime import datetime
 
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from config import DakinyConfig
+from database_setup.sql_data_classes import CouncilMembers, Votes, engine
+
 
 def get_datetime(day: str) -> datetime:
     """
@@ -24,3 +30,74 @@ def get_datetime(day: str) -> datetime:
         year += 1
 
     return datetime(year, month, day)
+
+
+def get_election_cycle_name(config: DakinyConfig) -> str:
+    """
+    Builds the unique name of the current election cycle
+
+    Returns:
+        str: the name of the election cycle
+    """
+    cycle = get_current_cycle(config)
+    current_cycle = config.election_cycles[cycle]
+
+    return f"vote-{get_datetime(current_cycle.election_start).year}-{current_cycle.name}"
+
+
+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.
+
+    Args:
+        config (DakinyConfig): Config object to use
+
+    Returns:
+        int: cycle index for active election. -1 for no active cycle
+    """
+
+    today = datetime.today()
+
+    for cycle, election in enumerate(config.election_cycles):
+        if (
+            today.date() >= get_datetime(election.election_start).date()
+            and today.date() <= get_datetime(election.term_start).date()
+        ):
+            return cycle
+
+    return -1
+
+
+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
+
+    Returns:
+        str: String that contains all nominees and their votes.
+    """
+
+    votes: dict[int, int] = {}
+
+    with Session(engine) as session:
+        stmt = select(CouncilMembers).where(CouncilMembers.ElectionCycle == get_election_cycle_name(config))
+
+        for nominee in session.scalars(stmt):
+            votes[nominee.MemberId] = 0
+
+        stmt = select(Votes).where(Votes.ElectionCycle == get_election_cycle_name(config))
+
+        for vote in session.scalars(stmt):
+            if vote.VotedForId is not None:
+                votes[vote.VotedForId] += 1
+
+    votes_str: str = "===================="
+    for user_id, num_votes in votes.items():
+        votes_str += f"\n<@{user_id}>: "
+
+        for num in range(num_votes):
+            votes_str += "☑️"
+
+    return votes_str