Change cutoff months for rollover.

Added the /time gametime command.

.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 viker.cheezers.net:5000/dakiny-bot:develop .
+        run: docker build -t gitea.cheezers.org/imcompiling/dakiny-bot:${{env.GIT_BRANCH}} .
       - name: Push Docker Image
-        run: docker push viker.cheezers.net:5000/dakiny-bot:develop
+        run: docker push gitea.cheezers.org/imcompiling/dakiny-bot:${{env.GIT_BRANCH}}

.gitea/workflows/build_latest.yml

@@ -14,7 +14,13 @@ 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 viker.cheezers.net:5000/dakiny-bot:latest .
+        run: docker build -t gitea.cheezers.org/imcompiling/dakiny-bot:latest .
       - name: Push Docker Image
-        run: docker push viker.cheezers.net:5000/dakiny-bot:latest
+        run: docker push gitea.cheezers.org/imcompiling/dakiny-bot:latest

.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

@@ -105,6 +105,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+poetry.lock
 
 # Spyder project settings
 .spyderproject
@@ -124,16 +125,17 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
-# IDE
-.vscode/
-
 # logging
 nextcord.log
 
-# data file for bot
+# bot files
 highscores_data.json
 highscores_config.json
 deleted_backups/
 highscores_data/
 TODO.txt
 sql_tester.py
+conf
+outputs
+database
+dakiny-messages/

.vscode/extensions.json

@@ -0,0 +1,9 @@
+{
+    "recommendations": [
+        "ms-python.vscode-pylance",
+        "ms-python.python",
+        "ms-python.debugpy",
+        "charliermarsh.ruff",
+        "alexcvzz.vscode-sqlite"
+    ]
+}

.vscode/launch.json

@@ -0,0 +1,15 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python: Module",
+            "type": "debugpy",
+            "request": "launch",
+            "module": "main",
+            "justMyCode": true
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "cSpell.words": [
+        "aiofiles",
+        "autofilled",
+        "blurple",
+        "CLANLEADER",
+        "Dakiny",
+        "DISCORDMANAGER",
+        "highcouncil"
+    ]
+}

DakinySettings.py

@@ -0,0 +1,83 @@
+"""File contains classes defining Dakiny settings structure."""
+
+from dataclasses import dataclass
+
+from dataclass_wizard import YAMLWizard
+
+CONFIG_LOCATION = "conf/config.yaml"
+
+
+@dataclass
+class ChannelIds:
+    """Class holds all channel ids needed by bot."""
+
+    admin: int  # might want to rename this...
+    announcement: int
+    clan_info: int
+    event_post: int
+    general: int
+    voting: int
+
+
+@dataclass
+class Election:
+    """Class defines relevant election dates."""
+
+    active: bool
+    election_start: str
+    highcouncil_election_announce: str
+    highcouncil_election_end: str
+    highcouncil_election_start: str
+    name: str
+    term_end: str
+    term_start: str
+    voting_end: str
+    voting_start: str
+
+
+@dataclass
+class EventSettings:
+    """Class defines settings editable by Clan Council."""
+
+    host_points: int
+    participate_points: int
+    verify: bool
+    weekly_limit: int
+
+
+@dataclass
+class Params:
+    """Class defines start parameters that shouldn't be changed."""
+
+    discord_token: str
+    git_branch: str
+    guild_id: int
+
+
+@dataclass
+class RoleIds:
+    """Class holds all role ids needed by bot."""
+
+    clan_council: int
+    clan_council_elect: int
+    clan_member: int
+    event_host: int
+    high_council: int
+
+
+@dataclass
+class DakinySettings(YAMLWizard):
+    """Class defines all configs required for Dakiny Bot."""
+
+    channel_ids: ChannelIds
+    election_cycles: list[Election]
+    event_settings: EventSettings
+    params: Params
+    role_ids: RoleIds
+
+    def save(self) -> None:
+        """Saves settings to the yaml file."""
+        self.to_yaml_file(CONFIG_LOCATION)
+
+
+settings = DakinySettings.from_yaml_file(CONFIG_LOCATION)

Dockerfile

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

README.md

@@ -1,50 +1,10 @@
-# 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")
+Dakiny clan's own discord bot!
-[![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")
 
-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.
+### 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.
-Nextcord documentation: https://nextcord.readthedocs.io/en/latest/
+Object creation in the middle of a cycle is only there for restarting the bot. All relevant information should already
-
+exist in the database.
-📺 Python Discord Tutorial: https://www.youtube.com/playlist?list=PL9YUC9AZJGFG6larkQJYio_f0V-O1NRjy
+- Bot is running on machine that is usint UTC time. All today() calls specify UTC time zone.
-
-## 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`.

classes/election.py

@@ -0,0 +1,389 @@
+"""Contains the election cycle class."""
+
+import collections
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+import nextcord
+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 DakinySettings import settings
+from database_setup.sql_data_classes import (
+    CouncilMembers,
+    ElectionInformation,
+    Votes,
+    engine,
+)
+from sqlalchemy import select, true, update
+from sqlalchemy.orm import Session
+from utils import (
+    TEMPLATES_DIR,
+    VoteType,
+    build_highcouncil_votes_str,
+    build_votes_str,
+    edit_clan_council_info,
+    get_datetime,
+    get_election_name,
+)
+
+REQUIRED_VOTES_TO_BE_ELECTED = 3
+
+
+class Election:
+    """
+    Election class.
+
+    This class represents all the dates required for an election cycle along with all the functions needed to operate
+    the cycle.
+    """
+
+    def __init__(self, cycle: int, guild: nextcord.Guild) -> None:
+        """
+        Generates all dates relevant to the election cycle determined by the config and cycle.
+
+        Args:
+            cycle (int): Which election cycle this cycle is.
+            guild (nextcord.Guild): The guild that this election is running in.
+        """
+        self.cycle = cycle
+        self.election_cycle = settings.election_cycles[self.cycle]
+        self.active = self.election_cycle.active
+        self.election_start: datetime = get_datetime(self.election_cycle.election_start)
+        self.term_start: datetime = get_datetime(self.election_cycle.term_start)
+        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.guild: nextcord.Guild = guild
+        self.election_over: bool = False
+
+    def build_election_announcement(self) -> list[str]:
+        """
+        Builds the messages to announce the election is starting.
+
+        Returns:
+            list[str]: A list of message contents in the correct order. Must be a string because the message is too
+            long.
+        """
+        with Path(f"{TEMPLATES_DIR}/election_announcement.txt", encoding="utf8").open() as file:
+            message = file.read()
+
+            next_election = get_datetime(
+                settings.election_cycles[(self.cycle + 1) % len(settings.election_cycles)].election_start
+            )
+
+            message = message.format(
+                clan_council_id=settings.role_ids.clan_council,
+                high_council_id=settings.role_ids.high_council,
+                election_start=self.election_start.strftime("%B %d"),
+                term_start=self.term_start.strftime("%B %d"),
+                term_end=self.term_end.strftime("%B %d"),
+                voting_start=self.voting_start.strftime("%B %d"),
+                voting_end=self.voting_end.strftime("%B %d"),
+                highcouncil_election=self.highcouncil_election_start.strftime("%B %d"),
+                next_election_start=next_election.strftime("%B %d"),
+            )
+
+            return message.split("---message_break---")
+
+    def build_highcouncil_election_announce(self) -> str:
+        """
+        Builds message to announce highcouncil election start.
+
+        Returns:
+            str: Message to send.
+        """
+        with Path(f"{TEMPLATES_DIR}/highcouncil_election.txt", encoding="utf8").open() as file:
+            message = file.read()
+
+            return message.format(
+                clan_council_elect_role_id=settings.role_ids.clan_council_elect,
+                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 Path(f"{TEMPLATES_DIR}/highcouncil_vote.txt", encoding="utf8").open() as file:
+            message = file.read()
+
+            return message.format(
+                clan_council_elect_role_id=settings.role_ids.clan_council_elect,
+                term_start=self.term_start.strftime("%B %d"),
+            )
+
+    def build_vote_start(self) -> str:
+        """
+        Builds the voting start message out of template and configurations.
+
+        Returns:
+            str: Message to send
+        """
+        with Path(f"{TEMPLATES_DIR}/vote_start.txt", encoding="utf8").open() as file:
+            message = file.read()
+            vote_end: datetime = get_datetime(settings.election_cycles[self.cycle].voting_end)
+
+            return message.format(
+                clan_member_id=settings.role_ids.clan_member,
+                voting_end=vote_end.strftime("%B %d"),
+                voting_end_day=vote_end.strftime("%A"),
+            )
+
+    async def check_date(self) -> None:
+        """Function checks current date to see if something needs to be run."""
+        today = datetime.now(tz=UTC)
+
+        # check all dates if action is needed
+        if today.date() == self.election_start.date():
+            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():
+            await self.election_reminder()
+        elif today.date() == self.voting_end.date():
+            await self.voting_end_action()
+        elif today.date() == self.highcouncil_election_start.date():
+            await self.highcouncil_election_start_action()
+        elif today.date() == self.term_start.date():
+            await self.term_start_action()
+
+    async def election_start_action(self) -> None:
+        """Performs required actions for when the election cycle starts."""
+        # create new channel for election
+        parent: nextcord.TextChannel = self.guild.get_channel(settings.channel_ids.voting)
+        quarter_name: str = get_election_name()
+
+        thread_msg: nextcord.Message = await parent.send(content=quarter_name)
+
+        thread: nextcord.Thread = await parent.create_thread(name=quarter_name, message=thread_msg)
+
+        # post message announcing election
+        # 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 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.guild))
+            else:
+                await thread.send(message)
+
+        # create new entry into database.
+        with Session(engine) as session:
+            new_cycle = ElectionInformation(
+                ElectionName=quarter_name,
+                ThreadId=thread.id,
+                CouncilNominationMsgId=nominate_msg.id,
+            )
+            session.add(new_cycle)
+            session.commit()
+
+    async def voting_start_action(self) -> None:
+        """
+        Actions performed when starting a vote.
+
+        Sends message informing members that voting has started.
+        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(settings, self.guild),
+            view=VoteView(self.guild),
+        )
+
+        with Session(engine) as session:
+            stmt = select(ElectionInformation).where(ElectionInformation.ElectionName == get_election_name())
+            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)
+
+    async def voting_end_action(self) -> None:
+        """Performs required actions for when voting time has ended."""
+        message = self.build_highcouncil_election_announce()
+        council_elect_role: nextcord.Role = self.guild.get_role(settings.role_ids.clan_council_elect)
+        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.guild))
+
+        election_name = get_election_name()
+
+        with Session(engine) as session:
+            # remove vote button from vote message
+            stmt = select(ElectionInformation).where(ElectionInformation.ElectionName == election_name)
+            info = session.scalar(stmt)
+            vote_msg: nextcord.Message = await election_thread.fetch_message(info.CouncilVoteMsgId)
+            await vote_msg.edit(view=None)
+
+            # add the highcouncil nomination message to election information
+            info.HighCouncilNominationMsgId = nominate_msg.id
+            session.commit()
+
+            # add the highcouncil role to everyone with 3 or more votes. set elected to true in database
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionName == election_name)
+                .where(Votes.Type == VoteType.COUNCIL)
+            )
+            vote_count = collections.Counter(session.scalars(stmt))
+
+            for user_id, votes in vote_count.items():
+                if votes >= REQUIRED_VOTES_TO_BE_ELECTED:
+                    stmt = (
+                        select(CouncilMembers)
+                        .where(CouncilMembers.ElectionName == election_name)
+                        .where(CouncilMembers.MemberId == user_id)
+                    )
+                    council_member = session.scalar(stmt)
+                    council_member.Elected = True
+                    session.commit()
+
+                    member: 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.",
+                    )
+
+    async def highcouncil_election_start_action(self) -> None:
+        """Performs required actions for when the highcouncil is elected."""
+        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.guild),
+            view=VoteHighcouncilView(self.guild),
+        )
+
+        with Session(engine) as session:
+            stmt = select(ElectionInformation).where(ElectionInformation.ElectionName == get_election_name())
+            info = session.scalar(stmt)
+            info.HighCouncilVoteMsgId = vote_msg.id
+            session.commit()
+
+            # remove highcouncil nomination view
+            nomination_msg: nextcord.Message = await election_thread.fetch_message(info.HighCouncilNominationMsgId)
+            await nomination_msg.edit(view=None)
+
+    async def term_start_action(self) -> None:
+        """Marks the election as over."""
+        self.election_over = True
+
+        elect_role: nextcord.Role = self.guild.get_role(settings.role_ids.clan_council_elect)
+        council_role: nextcord.Role = self.guild.get_role(settings.role_ids.clan_council)
+
+        election_name = get_election_name()
+
+        with Session(engine) as session:
+            # role management
+            stmt = (
+                select(CouncilMembers.MemberId)
+                .where(CouncilMembers.ElectionName == election_name)
+                .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.
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionName == election_name)
+                .where(Votes.Type == VoteType.DISCORDMANAGER)
+            )
+            dm_votes = collections.Counter(session.scalars(stmt))
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionName == election_name)
+                .where(Votes.Type == VoteType.CLANLEADER)
+            )
+            cl_votes = collections.Counter(session.scalars(stmt))
+
+            try:
+                dm_winner = max(dm_votes, key=dm_votes.get)
+                stmt = (
+                    update(CouncilMembers)
+                    .where(CouncilMembers.ElectionName == election_name)
+                    .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.ElectionName == election_name)
+                    .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.ElectionName == get_election_name()
+        )
+        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!\nClan 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)
+
+    def get_election_info(self) -> ElectionInformation:
+        """
+        Gets information for current election.
+
+        Returns:
+            ElectionInformation: The information from the database about the current election.
+        """
+        with Session(engine) as session:
+            stmt = select(ElectionInformation).where(ElectionInformation.ElectionName == get_election_name())
+            return session.scalar(stmt)
+
+    async def election_reminder(self) -> None:
+        """Sends a message to general chat reminder clan about election."""
+        general: nextcord.TextChannel = self.guild.get_channel(settings.channel_ids.general)
+
+        message = f"Reminder to <@&{settings.role_ids.clan_member}>! Clan elections are happening! Head over "
+        message += f"to <#{self.get_election_info().ThreadId}> to cast your vote!"
+
+        await general.send(content=message)

classes/election_cycle.py

@@ -1,102 +0,0 @@
-"""
-Contains the election cycle class
-"""
-
-from datetime import datetime, timedelta
-
-import nextcord
-from nextcord.ext import commands
-
-
-class ElectionCycle:
-    """
-    This class represents all the dates required for an election cycle along with all the functions needed to operate
-    the cycle.
-    """
-
-    def __init__(self, election_start: datetime, term_start: datetime, term_end: datetime, bot) -> None:
-        """
-        Generates all dates relevant to the election cycle from input election start, term start and end dates.
-
-        Args:
-            election_start (datetime): Date the election cycle starts.
-            term_start (datetime): Date the term being elected starts.
-            term_end (datetime): Date the term being elected ends.
-            bot: the discord bot instance
-        """
-        self._election_start: datetime = election_start
-        self._term_start: datetime = term_start
-        self._term_end: datetime = term_end  # might not be needed
-        self._voting_start: datetime = self._election_start + timedelta(days=1)
-        self._voting_end: datetime = self._voting_start + timedelta(days=1)
-        self._highcouncil_election: datetime = self._voting_end + timedelta(days=1)
-        self._bot: commands.Bot = bot
-
-    async def check_date(self) -> None:
-        """
-        Function checks current date to see if something needs to be run.
-        """
-        today = datetime.today()
-        print("checking the date")
-
-        # check all dates if action is needed
-        if today.date() == self._election_start.date():
-            await self.election_start_action()
-        elif today.date() == self._voting_start.date():
-            await self.voting_end_action()
-        elif today.date() == self._voting_end.date():
-            await self.voting_end_action()
-        elif today.date() == self._highcouncil_election.date():
-            await self.highcouncil_election_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()
-        else:
-            print("today was not a special date")
-            print(today)
-
-    async def election_start_action(self) -> None:
-        """
-        Performs required actions for when the election cycle starts.
-        """
-        print("election cycle has started")
-        await self.message_me("election cycle has started")
-
-    async def voting_start_action(self) -> None:
-        """
-        Performs required actions for when voting for candidates starts.
-        """
-        print("Voting has started")
-        await self.message_me("Voting has started")
-
-    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:
-        """
-        Performs required actions for when the highcouncil is elected.
-        """
-        print("Highcouncil election has started.")
-        await self.message_me("Highcouncil election has started.")
-
-    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
-        """
-        imcompiling: nextcord.User = await self._bot.fetch_user(206602713511886849)
-        await imcompiling.send(msg)

classes/gitea_webhook.py

@@ -0,0 +1,193 @@
+# generated by datamodel-codegen:
+#   filename:  gitea_webhook.json
+#   timestamp: 2024-05-16T21:15:27+00:00
+
+from __future__ import annotations
+
+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

@@ -0,0 +1,228 @@
+"""Contains various views to be used in the high council nomination process."""
+
+import nextcord
+from DakinySettings import settings
+from database_setup.sql_data_classes import CouncilMembers, engine
+from nextcord.interactions import Interaction
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+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,
+        usr_id: int,
+        usr_nominated: bool,  # noqa: FBT001
+        speech_content: str,
+    ):
+        super().__init__(
+            "Discord Manager Nomination",
+            timeout=5 * 60,  # 5 minutes
+        )
+        self.usr_id: int = usr_id
+        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
+            election_name = get_election_name()
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionName == election_name)
+                .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,
+        usr_id: int,
+        usr_nominated: bool,  # noqa: FBT001
+        speech_content: str,
+    ):
+        super().__init__(
+            "Clan Leader Nomination",
+            timeout=5 * 60,  # 5 minutes
+        )
+        self.usr_id: int = usr_id
+        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
+            election_name = get_election_name()
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionName == election_name)
+                .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, guild: nextcord.Guild):
+        super().__init__(timeout=None)
+        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:  # noqa: ARG002
+        """
+        Button for nominating oneself for Discord Manager.
+
+        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(settings.role_ids.clan_council_elect) not in interaction.user.roles:
+            await interaction.response.send_message(
+                f"You must have the <@&{settings.role_ids.clan_council_elect}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        election_name = get_election_name()
+        usr_nominated = False
+        speech_content = ""
+        with Session(engine) as session:
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionName == election_name)
+                .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(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:  # noqa: ARG002
+        """
+        Button for nominating oneself for Clan Leader.
+
+        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(settings.role_ids.clan_council_elect) not in interaction.user.roles:
+            await interaction.response.send_message(
+                f"You must have the <@&{settings.role_ids.clan_council_elect}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        election_name = get_election_name()
+        usr_nominated = False
+        speech_content = ""
+        with Session(engine) as session:
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionName == election_name)
+                .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(interaction.user.id, usr_nominated, speech_content))

classes/nominate_views.py

@@ -0,0 +1,123 @@
+"""Contains various views to be used in the nomination process."""
+
+import nextcord
+from DakinySettings import settings
+from database_setup.sql_data_classes import CouncilMembers, engine
+from nextcord.interactions import Interaction
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+from utils import NOMINEE_SPLITTER, decorate_nomination, get_election_name
+
+
+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,
+        usr_id: int,
+        usr_nominated: bool,  # noqa: FBT001
+        speech_content: str,
+    ):
+        super().__init__(
+            "Nomination",
+            timeout=5 * 60,  # 5 minutes
+        )
+        self.usr_id: int = usr_id
+        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)
+        election_name = get_election_name()
+
+        with Session(engine) as session:
+            if not self.usr_nominated:
+                msg = await interaction.channel.send(speech)
+
+                council_member = CouncilMembers(
+                    ElectionName=election_name,
+                    MemberId=interaction.user.id,
+                    SpeechMsgId=msg.id,
+                )
+                session.add(council_member)
+                session.commit()
+            else:
+                # user already nominated, just need to update the election speech
+                stmt = (
+                    select(CouncilMembers)
+                    .where(CouncilMembers.ElectionName == election_name)
+                    .where(CouncilMembers.MemberId == self.usr_id)
+                )
+                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))
+
+
+class NominateView(nextcord.ui.View):
+    """The button to press to start your nomination."""
+
+    def __init__(self, guild: nextcord.Guild):
+        super().__init__(timeout=None)
+        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:  # noqa: ARG002
+        """
+        Button to nominate oneself for Clan Council.
+
+        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 members only
+        if self.guild.get_role(settings.role_ids.clan_member) not in interaction.user.roles:
+            await interaction.response.send_message(
+                f"You must have the <@&{settings.role_ids.clan_member}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        election_name = get_election_name()
+        usr_nominated = False
+        speech_content = ""
+        with Session(engine) as session:
+            stmt = (
+                select(CouncilMembers)
+                .where(CouncilMembers.ElectionName == election_name)
+                .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(interaction.user.id, usr_nominated, speech_content))

classes/pyproject.toml

@@ -0,0 +1,10 @@
+[tool.ruff]
+# Extend the `pyproject.toml` file in the parent directory...
+extend = "../pyproject.toml"
+
+# Exclude a variety of commonly ignored directories.
+exclude = ["gitea_webhook.py"]
+
+[tool.ruff.lint]
+# ignore implicit-namespace-package in this directory.
+ignore = ["INP001"]

classes/voting_highcouncil_views.py

@@ -0,0 +1,236 @@
+"""Contains various views to be used while voting for high council. Controls the logic when performing the vote."""
+
+import nextcord
+from DakinySettings import settings
+from database_setup.sql_data_classes import (
+    CouncilMembers,
+    ElectionInformation,
+    Votes,
+    engine,
+)
+from nextcord import SelectOption
+from nextcord.interactions import Interaction
+from sqlalchemy import exc, select, update
+from sqlalchemy.orm import Session
+from utils import VoteType, build_highcouncil_votes_str, get_election_name
+
+
+class VoteSelect(nextcord.ui.StringSelect):
+    """Vote view string select."""
+
+    def __init__(self, options: list["SelectOption"], election_type: str) -> None:
+        super().__init__(
+            placeholder="Choose 1",
+            min_values=1,
+            max_values=1,
+            options=options,
+        )
+        self.election_type = election_type
+
+    async def callback(self, interaction: Interaction) -> None:
+        """
+        Callback override for the StringSelect.
+
+        Submits the High Council vote to database if a user is selected. Handles adding vs editing a vote.
+        Returns message informing user that vote has been recorded.
+
+        Args:
+            interaction (Interaction): Interaction with this callback.
+        """
+        election_name: str = get_election_name()
+        with Session(engine) as session:
+            stmt = select(ElectionInformation.HighCouncilVoteMsgId).where(
+                ElectionInformation.ElectionName == election_name
+            )
+            vote_msg_id = session.scalar(stmt)
+
+            voted_for = None if self.values[0] == "Abstain" else int(self.values[0])
+
+            new_vote = Votes(
+                ElectionName=election_name,
+                VoterId=interaction.user.id,
+                VotedForId=voted_for,
+                Type=self.election_type,
+            )
+
+            try:
+                session.add(new_vote)
+                session.commit()
+
+            except exc.IntegrityError:
+                # user already has a vote in the election and election type
+                session.rollback()
+                stmt = (
+                    update(Votes)
+                    .where(Votes.ElectionName == election_name)
+                    .where(Votes.VoterId == interaction.user.id)
+                    .where(Votes.Type == self.election_type)
+                    .values(VotedForId=voted_for)
+                )
+                session.execute(stmt)
+                session.commit()
+
+        vote_message_str = build_highcouncil_votes_str(interaction.guild)
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(vote_msg_id)
+        await vote_msg.edit(content=vote_message_str)
+
+        msg = f"You have voted for <@{voted_for}>" if voted_for is not None else "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, guild: nextcord.Guild):
+        super().__init__(timeout=None)
+        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:  # noqa: ARG002
+        """
+        Button to vote for Clan Leader.
+
+        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(settings.role_ids.clan_council_elect) not in interaction.user.roles:
+            await interaction.response.send_message(
+                f"You must have the <@&{settings.role_ids.clan_council_elect}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        election_name: str = get_election_name()
+
+        with Session(engine) as session:
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionName == election_name)
+                .where(Votes.VoterId == interaction.user.id)
+                .where(Votes.Type == VoteType.CLANLEADER)
+            )
+            voted_for = session.scalar(stmt)
+
+            stmt = (
+                select(CouncilMembers.MemberId)
+                .where(CouncilMembers.ElectionName == election_name)
+                .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.lower(),
+                )
+            ]
+            options.append(
+                SelectOption(
+                    label="Abstain ☑️" if voted_for is None else "Abstain",
+                    value="Abstain",
+                )
+            )
+
+        view = nextcord.ui.View()
+        view.add_item(VoteSelect(options=options, election_type=VoteType.CLANLEADER))
+
+        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:  # noqa: ARG002
+        """
+        Button to vote for Discord Manager.
+
+        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(settings.role_ids.clan_council_elect) not in interaction.user.roles:
+            await interaction.response.send_message(
+                f"You must have the <@&{settings.role_ids.clan_council_elect}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        election_name: str = get_election_name()
+
+        with Session(engine) as session:
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionName == election_name)
+                .where(Votes.VoterId == interaction.user.id)
+                .where(Votes.Type == VoteType.DISCORDMANAGER)
+            )
+            voted_for = session.scalar(stmt)
+
+            stmt = (
+                select(CouncilMembers.MemberId)
+                .where(CouncilMembers.ElectionName == election_name)
+                .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.lower(),
+                )
+            ]
+            options.append(
+                SelectOption(
+                    label="Abstain ☑️" if voted_for is None else "Abstain",
+                    value="Abstain",
+                )
+            )
+
+        view = nextcord.ui.View()
+        view.add_item(
+            VoteSelect(
+                options=options,
+                election_type=VoteType.DISCORDMANAGER,
+            )
+        )
+
+        await interaction.response.send_message(
+            content="Please vote for a Discord Manager!",
+            view=view,
+            ephemeral=True,
+        )

classes/voting_views.py

@@ -0,0 +1,146 @@
+"""Contains various views to be used while voting. Controls the logic when performing the vote."""
+
+import nextcord
+from DakinySettings import settings
+from database_setup.sql_data_classes import (
+    CouncilMembers,
+    ElectionInformation,
+    Votes,
+    engine,
+)
+from nextcord import SelectOption
+from nextcord.interactions import Interaction
+from sqlalchemy import exc, select, update
+from sqlalchemy.orm import Session
+from utils import VoteType, build_votes_str, get_election_name
+
+
+class VoteSelect(nextcord.ui.StringSelect):
+    """Vote view string select."""
+
+    def __init__(self, options: list["SelectOption"]) -> None:
+        super().__init__(
+            placeholder="Choose 1",
+            min_values=1,
+            max_values=1,
+            options=options,
+        )
+
+    async def callback(self, interaction: Interaction) -> None:
+        """
+        Callback override for the StringSelect.
+
+        Submits the vote to database if a user is selected. Handles adding vs editing a vote. Returns message
+        informing user that vote has been recorded.
+
+        Args:
+            interaction (Interaction): Interaction with this callback.
+        """
+        election_name = get_election_name()
+        with Session(engine) as session:
+            stmt = select(ElectionInformation.CouncilVoteMsgId).where(ElectionInformation.ElectionName == election_name)
+            vote_msg_id = session.scalar(stmt)
+
+            voted_for = None if self.values[0] == "Abstain" else int(self.values[0])
+
+            new_vote = Votes(
+                ElectionName=election_name,
+                VoterId=interaction.user.id,
+                VotedForId=voted_for,
+                Type=VoteType.COUNCIL,
+            )
+
+            try:
+                session.add(new_vote)
+                session.commit()
+
+            except exc.IntegrityError:
+                session.rollback()
+                stmt = (
+                    update(Votes)
+                    .where(Votes.ElectionName == election_name)
+                    .where(Votes.VoterId == interaction.user.id)
+                    .where(Votes.Type == VoteType.COUNCIL)
+                    .values(VotedForId=voted_for)
+                )
+                session.execute(stmt)
+                session.commit()
+
+        vote_message_str = build_votes_str(settings, interaction.guild)
+        vote_msg: nextcord.Message = await interaction.channel.fetch_message(vote_msg_id)
+        await vote_msg.edit(content=vote_message_str)
+
+        msg = f"You have voted for <@{voted_for}>" if voted_for is not None else "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, guild: nextcord.Guild):
+        super().__init__(timeout=None)
+        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:  # noqa: ARG002
+        """
+        Enforces only members vote.
+
+        Gets election cycle, creates voting options (checking if user has voted already),
+        then sends the voting view.
+
+        Args:
+            button (nextcord.ui.Button): Unused. idk why its needed in the decorator
+            interaction (nextcord.Interaction): Interaction of user who pressed the button
+        """
+        # enforce members only
+        if self.guild.get_role(settings.role_ids.clan_member) not in interaction.user.roles:
+            await interaction.response.send_message(
+                f"You must have the <@&{settings.role_ids.clan_member}> role to vote.",
+                ephemeral=True,
+            )
+            return
+
+        election_name: str = get_election_name()
+
+        with Session(engine) as session:
+            stmt = (
+                select(Votes.VotedForId)
+                .where(Votes.ElectionName == election_name)
+                .where(Votes.VoterId == interaction.user.id)
+                .where(Votes.Type == VoteType.COUNCIL)
+            )
+            voted_for = session.scalar(stmt)
+
+            stmt = select(CouncilMembers.MemberId).where(CouncilMembers.ElectionName == election_name)
+
+            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.lower(),
+                )
+            ]
+            options.append(
+                SelectOption(
+                    label="Abstain ☑️" if voted_for is None else "Abstain",
+                    value="Abstain",
+                )
+            )
+
+        view = nextcord.ui.View()
+        view.add_item(VoteSelect(options))
+
+        await interaction.response.send_message(
+            content="Please vote for a clan member!",
+            view=view,
+            ephemeral=True,
+        )

cogs/clan_messages/__init__.py

@@ -0,0 +1,91 @@
+"""File contains logic for creating a webhook listener, pulling from git, and updating all messages."""
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import uvicorn
+from fastapi import FastAPI
+from git import Repo
+from nextcord.ext import commands
+
+from classes.gitea_webhook import GiteaWebhook
+from DakinySettings import settings
+from utils import REPO_DIR, edit_clan_council_info, update_clan_messages
+
+if TYPE_CHECKING:
+    import nextcord
+
+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.repo_setup()
+
+    @commands.Cog.listener()
+    async def on_ready(self) -> None:
+        """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"])
+        # Bind to all interfaces, don't know the docker interface ahead of time.
+        config = uvicorn.Config(app=app, host="0.0.0.0", port=5000, log_level="info")  # noqa: S104
+        server = uvicorn.Server(config)
+        await server.serve()
+
+    async def update_messages(self, hook_info: GiteaWebhook) -> dict:
+        """
+        Triggered by webhook.
+
+        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 files in [commit.modified + commit.added for commit in hook_info.commits] for file in files
+        ]
+
+        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(settings.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(settings.params.guild_id))
+
+        return {"message": "Successfully updated all discord messages."}
+
+    def repo_setup(self) -> None:
+        """Checks if the repo exists and creates repo object, clones if it does not."""
+        # check if repo has been cloned. open repo object
+        if Path(REPO_DIR).is_dir():
+            self.repo = Repo(REPO_DIR)
+        else:
+            self.repo = Repo.clone_from(REPO_URL, REPO_DIR)
+
+        self.origin = self.repo.remote("origin")
+
+        if settings.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) -> None:
+    """Adds function to bot."""
+    bot.add_cog(ClanMessages(bot))

cogs/commands/__init__.py

@@ -0,0 +1,28 @@
+"""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.settings import SettingsCog
+from cogs.commands.test import TestCog
+from cogs.commands.time import TimeCog
+from cogs.commands.view import ViewCog
+
+
+# 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) -> None:
+    """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(SetCog())
+    bot.add_cog(SettingsCog())
+    bot.add_cog(TestCog(bot))
+    bot.add_cog(TimeCog())
+    bot.add_cog(ViewCog())

cogs/commands/record.py

@@ -0,0 +1,354 @@
+"""Contained commands and views for record commands."""
+
+import nextcord
+from discord import TextInputStyle
+from nextcord.ext import commands
+
+from DakinySettings import settings
+from utils import GUILDS, MAX_DISCORD_MESSAGE_LENGTH, record_event_points
+
+
+class RecordCog(commands.Cog, name="Record Commands"):
+    """Class holds record commands."""
+
+    def __init__(self, bot: commands.Bot) -> None:
+        """Default constructor for RecordCog class. Does nothing."""
+        super().__init__()
+        self.bot: commands.Bot = bot
+
+    @nextcord.slash_command(guild_ids=GUILDS)
+    async def record(self, interaction: nextcord.Interaction) -> None:
+        """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.",
+        ),
+    ) -> None:
+        """
+        Create and send recording event.
+
+        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(settings.role_ids.event_host) not in interaction.user.roles:
+            await interaction.response.send_message(
+                f"You must have the <@&{settings.role_ids.event_host}> 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, host.id),
+            ephemeral=True,
+            embed=embed,
+        )
+
+    @record.subcommand(description="Record a miscellaneous point for a clan member.")
+    async def point(
+        self,
+        interaction: nextcord.Interaction,
+        activity: str = nextcord.SlashOption(
+            description="The type of activity to receive points for.",
+            required=True,
+            choices=[
+                "Clan chat activity",
+                "Teaching or sharing in-game tips",
+                "Recruiting efforts",
+                "Successful recruitment",
+            ],
+        ),
+        justification: str = nextcord.SlashOption(
+            required=True,
+            description="Reason to give the recipient a point.",
+            max_length=int(MAX_DISCORD_MESSAGE_LENGTH / 2),
+        ),
+        recipient: nextcord.Member = nextcord.SlashOption(
+            required=False,
+            description="Discord user to give point to.",
+        ),
+        non_discord_recipient: str = nextcord.SlashOption(
+            required=False, description="Non Discord user to give point to.", max_length=32
+        ),
+    ) -> None:
+        """
+        Gives a point to the provided recipient. Sends recording message to event participation channel.
+
+        Only one recipient should be given point/provided to the command. Fails if not exactly one recipient
+        is given.
+
+        Args:
+            interaction (nextcord.Interaction): interaction with this command.
+            activity (str): Choice list of activities to give point for.
+            justification (str): Reason to give point.
+            recipient (nextcord.Member): Discord member to give point to.
+            non_discord_recipient (str): Non Discord member to give point to.
+        """
+        # role check
+        if interaction.guild.get_role(settings.role_ids.clan_member) not in interaction.user.roles:
+            await interaction.response.send_message(
+                f"You must have the <@&{settings.role_ids.clan_member}> role to record points.",
+                ephemeral=True,
+            )
+            return
+
+        # pylint or whatever seems to think that there are lines of unreachable code. That is false.
+        if recipient and non_discord_recipient:
+            await interaction.response.send_message("Please only provide 1 recipient.", ephemeral=True)
+            return
+        elif recipient is not None:  # noqa: RET505
+            record_event_points(
+                [str(recipient.id)],
+                settings.event_settings.participate_points,
+                is_member=True,
+            )
+            recipient_str = f"<@{recipient.id}>"
+        elif non_discord_recipient is not None:
+            record_event_points(
+                [non_discord_recipient],
+                settings.event_settings.participate_points,
+                is_member=False,
+            )
+            recipient_str = f'"{non_discord_recipient}"'
+        else:
+            await interaction.response.send_message("You must provide a recipient.", ephemeral=True)
+            return
+
+        event_channel: nextcord.TextChannel = interaction.guild.get_channel(settings.channel_ids.event_post)
+
+        msg = f"<@{interaction.user.id}> has given {recipient_str} points for the {activity} activity. Justification: {justification}"  # noqa: E501
+        if not msg.endswith("."):
+            msg += "."
+        await event_channel.send(msg)
+        await interaction.response.send_message("Point has been added.", ephemeral=True)
+
+
+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, host_id: int):
+        super().__init__()
+
+        self.name: str = name
+        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) -> None:  # noqa: ARG002
+        """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) -> None:  # noqa: ARG002
+        """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) -> None:  # noqa: ARG002
+        """
+        Submits the event embed to the event channel.
+
+        Removes view and embed from recording message.
+        Sends point information to database.
+        """
+        if settings.event_settings.verify:
+            verification_channel: nextcord.TextChannel = interaction.guild.get_channel(settings.channel_ids.admin)
+            verification_view = EventVerification(
+                self.event_participants.values.members, interaction.message.embeds[0].fields[1].value, self.host_id
+            )
+            await verification_channel.send(
+                content="Event record request.", embed=interaction.message.embeds[0], view=verification_view
+            )
+            submission_response = "Event has been submitted to admins for approval."
+        else:
+            process_event(
+                self.event_participants.values.members,
+                interaction.message.embeds[0].fields[1].value,
+                self.host_id,
+            )
+
+            event_channel: nextcord.TextChannel = interaction.guild.get_channel(settings.channel_ids.event_post)
+            await event_channel.send(embed=interaction.message.embeds[0])
+            submission_response = "Event has been submitted."
+
+        await interaction.response.edit_message(content=submission_response, view=None, embed=None)
+        self.stop()
+
+
+class EventVerification(nextcord.ui.View):
+    """Class contains code to approve/deny event submissions."""
+
+    def __init__(
+        self,
+        discord_users: list[nextcord.Member],
+        non_discord_users: str,
+        host_id: int,
+    ):
+        super().__init__(timeout=None, auto_defer=True)
+        self.discord_users: list[nextcord.Member] = discord_users
+        self.non_discord_users: str = non_discord_users
+        self.host_id: int = host_id
+
+    @nextcord.ui.button(label="Approve", style=nextcord.ButtonStyle.green)
+    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
+        """
+        Approve button for an event submission.
+
+        Calls the process event function. Records who approved the event.
+        Removes the view from the interaction message.
+
+        Args:
+            button (nextcord.ui.Button): Unused.
+            interaction (nextcord.Interaction): The interaction of the user clicking the button.
+        """
+        process_event(self.discord_users, self.non_discord_users, self.host_id)
+        event_channel: nextcord.TextChannel = interaction.guild.get_channel(settings.channel_ids.event_post)
+        await event_channel.send(embed=interaction.message.embeds[0])
+
+        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) -> None:  # noqa: ARG002
+        """
+        Deny button for an event submission. 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 = f"\nDenied by <@{interaction.user.id}>."
+        await interaction.response.edit_message(content=content, view=None)
+
+
+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.
+    """
+
+    # consider turning this embed into a dict
+    def __init__(self, embed: nextcord.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) -> None:
+        """
+        Edits the interaction message to contain the Non-Discord participants.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction of the callback.
+        """
+        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) -> None:
+        """
+        Edits the interaction message to contain the Discord participants.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction of the callback.
+        """
+        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)
+
+
+def process_event(discord_users: list[nextcord.Member], non_discord_users: str, host_id: int) -> None:
+    """
+    Processes all points to give to participants and host for an event.
+
+    Args:
+        discord_users (list[nextcord.Member]): List of discord members that participated in event.
+        non_discord_users (str): Newline separated list of non discord members that participated in event.
+        host_id (int): Discord ID of host.
+    """
+    if discord_users:
+        discord_users_list: list[str] = [str(user.id) for user in discord_users if user.id is not host_id]
+        record_event_points(
+            discord_users_list,
+            settings.event_settings.participate_points,
+            is_member=True,
+        )
+
+    if non_discord_users:
+        non_discord_users_list: list[str] = non_discord_users.split("\n")
+        record_event_points(
+            non_discord_users_list,
+            settings.event_settings.participate_points,
+            is_member=False,
+        )
+
+    record_event_points([host_id], settings.event_settings.host_points, is_member=True)

cogs/commands/refresh.py

@@ -0,0 +1,65 @@
+"""Contained commands and views for refresh commands."""
+
+import os
+from pathlib import Path
+
+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: commands.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) -> None:
+        """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,
+        ),
+    ) -> None:
+        """
+        Updates all messages.
+
+        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 Path(f"{MESSAGES_DIR}/{dir_name}").is_dir()
+            ]
+        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) -> None:
+        """
+        Edits the clan council info message.
+
+        Calls edit_clan_council_info().
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the command.
+        """
+        await edit_clan_council_info(interaction.guild)
+        await interaction.response.send_message("Clan Council Info message updated.", ephemeral=True)

cogs/commands/remove.py

@@ -0,0 +1,67 @@
+"""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) -> None:
+        """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),
+    ) -> None:
+        """
+        Deletes the given presence id from the database.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            presence_str (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) -> None:
+        """
+        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

@@ -0,0 +1,168 @@
+"""Contains commands and views for request commands."""
+
+import nextcord
+from nextcord.ext import commands
+from sqlalchemy.orm import Session
+
+from DakinySettings import settings
+from database_setup.sql_data_classes import Presences, engine
+
+
+class RequestCog(commands.Cog, name="Request Commands"):
+    """Class holds request commands."""
+
+    def __init__(self, bot: commands.Bot) -> None:
+        """Default constructor for RequestCog class. Does nothing."""
+        self.bot: commands.Bot = bot
+
+    @nextcord.slash_command()
+    async def request(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for request. 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.",
+        ),
+    ) -> None:
+        """
+        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.
+        """
+        content = f'<@{interaction.user.id}> would like to add presence "{presence}."'
+        view = PresenceChange(presence)
+        await self.bot.get_channel(settings.channel_ids.admin).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.",
+        ),
+    ) -> None:
+        """
+        Sends a message to admins to request a nickname change.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+            new_nickname(str): The username to change to.
+        """
+        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(settings.channel_ids.admin).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,
+    ):
+        super().__init__(timeout=None, auto_defer=True)
+        self.user_id = user_id
+        self.new_nickname = new_nickname
+
+    @nextcord.ui.button(label="Approve", style=nextcord.ButtonStyle.green)
+    async def approve(self, button: nextcord.ui.Button, interaction: nextcord.Interaction) -> None:  # noqa: ARG002
+        """
+        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 occurred 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) -> None:  # noqa: ARG002
+        """
+        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)
+
+
+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) -> None:  # noqa: ARG002
+        """
+        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) -> None:  # noqa: ARG002
+        """
+        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

@@ -0,0 +1,76 @@
+"""Contains commands and views for set commands."""
+
+from datetime import UTC, datetime
+
+import nextcord
+from nextcord.ext import commands
+from sqlalchemy import delete, select
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session
+
+from database_setup.sql_data_classes import UserBirthday, engine
+from main import birthday_list
+
+
+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) -> None:
+        """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."),
+    ) -> None:
+        """
+        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.now(tz=UTC)
+        try:
+            birthday = datetime(today.year, month, day, tzinfo=UTC)
+        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/settings.py

@@ -0,0 +1,321 @@
+"""Contains commands and views for settings commands."""
+
+import nextcord
+from nextcord.ext import commands
+
+from DakinySettings import settings
+from utils import GUILDS
+
+
+class SettingsCog(commands.Cog, name="Settings Commands"):
+    """Class holds settings commands."""
+
+    def __init__(self) -> None:
+        """Default constructor for SettingsCog class. Does nothing."""
+
+    @nextcord.slash_command(guild_ids=GUILDS, default_member_permissions=nextcord.Permissions(administrator=True))
+    async def settings(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for settings. Never called."""
+
+    @settings.subcommand()
+    async def channel_ids(self, interaction: nextcord.Interaction) -> None:
+        """Subcommand parent. Never called."""
+
+    @channel_ids.subcommand(description="Sets channel that bot sends verification requests to admins.")
+    async def admin(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.TextChannel = nextcord.SlashOption(
+            required=False, description="Channel to set to. If left blank, uses current channel."
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings channel_ids.admin value to given channel id or current channel id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            channel (nextcord.TextChannel, optional): Channel to set in settings.
+        """
+        channel_id = interaction.channel_id if channel is None else channel.id
+        settings.channel_ids.admin = channel_id
+        settings.save()
+        await interaction.response.send_message(f"Admin verification channel set to <#{channel_id}>.", ephemeral=True)
+
+    @channel_ids.subcommand(description="Sets announcement channel.")
+    async def announcement(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.TextChannel = nextcord.SlashOption(
+            required=False, description="Channel to set to. If left blank, uses current channel."
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings channel_ids.announcement value to given channel id or current channel id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            channel (nextcord.TextChannel, optional): Channel to set in settings.
+        """
+        channel_id = interaction.channel_id if channel is None else channel.id
+        settings.channel_ids.announcement = channel_id
+        settings.save()
+        await interaction.response.send_message(f"Announcement channel set to <#{channel_id}>.", ephemeral=True)
+
+    @channel_ids.subcommand(description="Sets clan info channel. Channel used for tracking current council.")
+    async def clan_info(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.TextChannel = nextcord.SlashOption(
+            required=False, description="Channel to set to. If left blank, uses current channel."
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings channel_ids.clan_info value to given channel id or current channel id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            channel (nextcord.TextChannel, optional): Channel to set in settings.
+        """
+        channel_id = interaction.channel_id if channel is None else channel.id
+        settings.channel_ids.clan_info = channel_id
+        settings.save()
+        await interaction.response.send_message(f"Clan information channel set to <#{channel_id}>.", ephemeral=True)
+
+    @channel_ids.subcommand(
+        description="Sets event post channel. Channel is where event tracking information is posted."
+    )
+    async def event_post(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.TextChannel = nextcord.SlashOption(
+            required=False, description="Channel to set to. If left blank, uses current channel."
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings channel_ids.event_post value to given channel id or current channel id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            channel (nextcord.TextChannel, optional): Channel to set in settings.
+        """
+        channel_id = interaction.channel_id if channel is None else channel.id
+        settings.channel_ids.event_post = channel_id
+        settings.save()
+        await interaction.response.send_message(f"Event posting channel set to <#{channel_id}>.", ephemeral=True)
+
+    @channel_ids.subcommand(description="Sets general channel.")
+    async def general(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.TextChannel = nextcord.SlashOption(
+            required=False, description="Channel to set to. If left blank, uses current channel."
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings channel_ids.general value to given channel id or current channel id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            channel (nextcord.TextChannel, optional): Channel to set in settings.
+        """
+        channel_id = interaction.channel_id if channel is None else channel.id
+        settings.channel_ids.general = channel_id
+        settings.save()
+        await interaction.response.send_message(f"General channel set to <#{channel_id}>.", ephemeral=True)
+
+    @channel_ids.subcommand(description="Sets voting channel. Channel used as parent for voting threads.")
+    async def voting(
+        self,
+        interaction: nextcord.Interaction,
+        channel: nextcord.TextChannel = nextcord.SlashOption(
+            required=False, description="Channel to set to. If left blank, uses current channel."
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings channel_ids.voting value to given channel id or current channel id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            channel (nextcord.TextChannel, optional): Channel to set in settings.
+        """
+        channel_id = interaction.channel_id if channel is None else channel.id
+        settings.channel_ids.voting = channel_id
+        settings.save()
+        await interaction.response.send_message(f"Voting channel set to <#{channel_id}>.", ephemeral=True)
+
+    @settings.subcommand()
+    async def event_settings(self, interaction: nextcord.Interaction) -> None:
+        """Subcommand parent. Never called."""
+
+    @event_settings.subcommand(description="Sets Event Host Points value.")
+    async def host_points(
+        self,
+        interaction: nextcord.Interaction,
+        points: int = nextcord.SlashOption(
+            required=True, description="Number of Event Points a host earns when hosting event.", min_value=0
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings event_settings.host_points to the given number of points.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            points (int): Number of points to set.
+        """
+        settings.event_settings.host_points = points
+        settings.save()
+        await interaction.response.send_message(f"Event Host Points set to {points}.", ephemeral=True)
+
+    @event_settings.subcommand(description="Sets Event Participation Points value.")
+    async def participate_points(
+        self,
+        interaction: nextcord.Interaction,
+        points: int = nextcord.SlashOption(
+            required=True,
+            description="Number of Event Points a participant earns when attending an event.",
+            min_value=0,
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings event_settings.participate_points to the given number of points.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            points (int): Number of points to set.
+        """
+        settings.event_settings.participate_points = points
+        settings.save()
+        await interaction.response.send_message(f"Event Participation Points set to {points}.", ephemeral=True)
+
+    @event_settings.subcommand(description="Sets Event Participation Points value.")
+    async def verify(
+        self,
+        interaction: nextcord.Interaction,
+        do_verification: bool = nextcord.SlashOption(  # noqa: FBT001
+            required=True,
+            description="Whether an event should be verified or not.",
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings event_settings.verify to the given number of points.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            do_verification (bool): If the bot should verify events.
+        """
+        settings.event_settings.verify = do_verification
+        settings.save()
+        await interaction.response.send_message(f"Event verification set to {do_verification}.", ephemeral=True)
+
+    @event_settings.subcommand(description="Sets Event Weekly Limit value.")
+    async def weekly_limit(
+        self,
+        interaction: nextcord.Interaction,
+        points: int = nextcord.SlashOption(
+            required=True, description="Number of Event Points a clan member can earn in a week.", min_value=0
+        ),
+    ) -> None:
+        """
+        Sets DakinySettings event_settings.weekly_limit to the given number of points.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            points (int): Number of points to set.
+        """
+        settings.event_settings.weekly_limit = points
+        settings.save()
+        await interaction.response.send_message(f"Event Weekly Limit set to {points}.", ephemeral=True)
+
+    @settings.subcommand()
+    async def role_ids(self, interaction: nextcord.Interaction) -> None:
+        """Subcommand parent. Never called."""
+
+    @role_ids.subcommand(description="Sets Clan Council role id.")
+    async def clan_council(
+        self,
+        interaction: nextcord.Interaction,
+        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
+    ) -> None:
+        """
+        Sets DakinySettings role_ids.clan_council to the given role id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            role (nextcord.TextChannel): Role to set in settings.
+        """
+        role_id = role.id
+        settings.role_ids.clan_council = role_id
+        settings.save()
+        await interaction.response.send_message(f"Clan Council role set to <@&{role_id}>.", ephemeral=True)
+
+    @role_ids.subcommand(description="Sets Clan Council Elect role id.")
+    async def clan_council_elect(
+        self,
+        interaction: nextcord.Interaction,
+        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
+    ) -> None:
+        """
+        Sets DakinySettings role_ids.clan_council_elect to the given role id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            role (nextcord.TextChannel): Role to set in settings.
+        """
+        role_id = role.id
+        settings.role_ids.clan_council_elect = role_id
+        settings.save()
+        await interaction.response.send_message(f"Clan Council Elect role set to <@&{role_id}>.", ephemeral=True)
+
+    @role_ids.subcommand(description="Sets Clan Member role id.")
+    async def clan_member(
+        self,
+        interaction: nextcord.Interaction,
+        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
+    ) -> None:
+        """
+        Sets DakinySettings role_ids.clan_member to the given role id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            role (nextcord.TextChannel): Role to set in settings.
+        """
+        role_id = role.id
+        settings.role_ids.clan_member = role_id
+        settings.save()
+        await interaction.response.send_message(f"Clan Member role set to <@&{role_id}>.", ephemeral=True)
+
+    @role_ids.subcommand(description="Sets Event Host role id.")
+    async def event_host(
+        self,
+        interaction: nextcord.Interaction,
+        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
+    ) -> None:
+        """
+        Sets DakinySettings role_ids.event_host to the given role id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            role (nextcord.TextChannel): Role to set in settings.
+        """
+        role_id = role.id
+        settings.role_ids.event_host = role_id
+        settings.save()
+        await interaction.response.send_message(f"Event Host role set to <@&{role_id}>.", ephemeral=True)
+
+    @role_ids.subcommand(description="Sets High Council role id.")
+    async def high_council(
+        self,
+        interaction: nextcord.Interaction,
+        role: nextcord.Role = nextcord.SlashOption(required=True, description="Role to set."),
+    ) -> None:
+        """
+        Sets DakinySettings role_ids.high_council to the given role id.
+
+        Args:
+            interaction (nextcord.Interaction): Discord interaction of command.
+            role (nextcord.TextChannel): Role to set in settings.
+        """
+        role_id = role.id
+        settings.role_ids.high_council = role_id
+        settings.save()
+        await interaction.response.send_message(f"High Council role set to <@&{role_id}>.", ephemeral=True)

cogs/commands/test.py

@@ -0,0 +1,155 @@
+"""Commands for testing."""
+
+import nextcord
+from nextcord.ext import application_checks, commands
+
+from classes.election import Election
+from DakinySettings import settings
+from utils import GUILDS, get_active_election_cycle, get_quarter_name
+
+ME = 206602713511886849
+
+
+def is_me():  # noqa: ANN201
+    """Predicate that makes sure only I can run the test commands."""
+
+    def predicate(interaction: nextcord.Interaction) -> bool:
+        return interaction.user.id == ME
+
+    return application_checks.check(predicate)
+
+
+class TestCog(commands.Cog, name="Test commands."):
+    """Class holds commands for testing."""
+
+    def __init__(self, bot: commands.Bot) -> None:
+        """Default constructor for HelpCog class. Does nothing."""
+        self.bot: commands.Bot = bot
+
+    @nextcord.slash_command(guild_ids=GUILDS)
+    async def test(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command for help. Never called."""
+
+    @test.subcommand()
+    @is_me()
+    async def election_start(self, interaction: nextcord.Interaction) -> None:
+        """
+        Force starts election.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
+        cycle = Election(
+            get_active_election_cycle(),
+            self.bot.get_guild(settings.params.guild_id),
+        )
+        await cycle.election_start_action()
+        await interaction.send("Test command sent.", ephemeral=True)
+
+    @test.subcommand()
+    @is_me()
+    async def voting_start(self, interaction: nextcord.Interaction) -> None:
+        """
+        Force starts voting.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
+        cycle = Election(
+            get_active_election_cycle(),
+            self.bot.get_guild(settings.params.guild_id),
+        )
+        await cycle.voting_start_action()
+        await interaction.send("Test command sent.", ephemeral=True)
+
+    @test.subcommand()
+    @is_me()
+    async def voting_end(self, interaction: nextcord.Interaction) -> None:
+        """
+        Force ends voting.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
+        cycle = Election(
+            get_active_election_cycle(),
+            self.bot.get_guild(settings.params.guild_id),
+        )
+        await cycle.voting_end_action()
+        await interaction.send("Test command sent.", ephemeral=True)
+
+    @test.subcommand()
+    @is_me()
+    async def highcouncil_vote(self, interaction: nextcord.Interaction) -> None:
+        """
+        Force starts highcouncil voting.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
+        cycle = Election(
+            get_active_election_cycle(),
+            self.bot.get_guild(settings.params.guild_id),
+        )
+        await cycle.highcouncil_election_start_action()
+        await interaction.send("Test command sent.", ephemeral=True)
+
+    @test.subcommand()
+    @is_me()
+    async def election_reminder(self, interaction: nextcord.Interaction) -> None:
+        """
+        Forces election reminder.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
+        cycle = Election(
+            get_active_election_cycle(),
+            self.bot.get_guild(settings.params.guild_id),
+        )
+        await cycle.election_reminder()
+        await interaction.send("Test command sent.", ephemeral=True)
+
+    @test.subcommand()
+    @is_me()
+    async def daily(self, interaction: nextcord.Interaction) -> None:
+        """
+        Forces daily function.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
+        cycle = Election(
+            get_active_election_cycle(),
+            self.bot.get_guild(settings.params.guild_id),
+        )
+        await cycle.check_date()
+        await interaction.send("Test command sent.", ephemeral=True)
+
+    @test.subcommand()
+    @is_me()
+    async def term_start(self, interaction: nextcord.Interaction) -> None:
+        """
+        Forces term start.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
+        cycle = Election(
+            get_active_election_cycle(),
+            self.bot.get_guild(settings.params.guild_id),
+        )
+        await cycle.term_start_action()
+        await interaction.send("Test command sent.", ephemeral=True)
+
+    @test.subcommand()
+    @is_me()
+    async def get_quarter_name(self, interaction: nextcord.Interaction) -> None:
+        """
+        Tests getting the quarter name.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+        """
+        name = get_quarter_name()
+        await interaction.send(name)

cogs/commands/time.py

@@ -0,0 +1,109 @@
+"""Contains commands for time commands."""
+
+from datetime import MAXYEAR, MINYEAR, UTC, datetime
+
+import nextcord
+from nextcord.ext import commands
+
+from utils import GUILDS
+
+
+class TimeCog(commands.Cog, name="Time Commands"):
+    """Class holds time commands."""
+
+    @nextcord.slash_command(guild_ids=GUILDS)
+    async def time(self, interaction: nextcord.Interaction) -> None:
+        """Parent slash command. Never called."""
+
+    @time.subcommand(
+        description="Get a discord timestamp of the given game time. If date information is left blank, uses current day."  # noqa: E501
+    )
+    async def at(  # noqa: PLR0913
+        self,
+        interaction: nextcord.Interaction,
+        hour: int = nextcord.SlashOption(
+            description="The hour you want a timestamp of. Given in gametime/UTC.",
+            min_value=0,
+            max_value=23,
+            required=True,
+        ),
+        minute: int = nextcord.SlashOption(
+            description="The minute you want a timestamp of. Given in gametime/UTC.",
+            min_value=0,
+            max_value=59,
+            required=True,
+        ),
+        year: int = nextcord.SlashOption(
+            description="Year to make timestamp of.", required=False, min_value=MINYEAR, max_value=MAXYEAR
+        ),
+        month: int = nextcord.SlashOption(
+            description="Month to make timestamp of.", required=False, min_value=1, max_value=12
+        ),
+        day: int = nextcord.SlashOption(
+            description="Day to make timestamp of.", required=False, min_value=1, max_value=31
+        ),
+        ephemeral: bool = nextcord.SlashOption(  # noqa: FBT001
+            description="Whether the replying message will be public or not.", required=False, default=True
+        ),
+    ) -> None:
+        """
+        Replies with a discord timestamp of given UTC time.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the command.
+            hour (int): The hour in UTC to make the timestamp of..
+            minute (int): The minute in UTC to make the timestamp of..
+            year (int): The year to make the timestamp of.
+            month (int): The month to make the timestamp of.
+            day (int): The day to make the timestamp of.
+            ephemeral (bool): Whether the response is ephemeral or not.
+        """
+        gametime_today: datetime = datetime.now(tz=UTC).replace(hour=hour, minute=minute)
+
+        if year is not None:
+            gametime_today = gametime_today.replace(year=year)
+
+        if month is not None and day is not None:
+            try:
+                gametime_today = gametime_today.replace(month=month, day=day)
+            except ValueError:
+                await interaction.response.send_message(f"Day {day} is out of range for month {month}.", ephemeral=True)
+                return
+        else:
+            if month is not None:
+                try:
+                    gametime_today = gametime_today.replace(month=month)
+                except ValueError:
+                    await interaction.response.send_message(
+                        f"Today ({gametime_today.day}) is out of range for month {month}.", ephemeral=True
+                    )
+                    return
+
+            if day is not None:
+                try:
+                    gametime_today = gametime_today.replace(day=day)
+                except ValueError:
+                    await interaction.response.send_message(
+                        f"Day {day} is out of range for this month {gametime_today.month}.", ephemeral=True
+                    )
+                    return
+
+        await interaction.response.send_message(content=f"<t:{int(gametime_today.timestamp())}:t>", ephemeral=ephemeral)
+
+    @time.subcommand(description="Get the current time in game.")
+    async def gametime(
+        self,
+        interaction: nextcord.Interaction,
+        ephemeral: bool = nextcord.SlashOption(  # noqa: FBT001
+            description="Whether the replying message will be public or not.", required=False, default=True
+        ),
+    ) -> None:
+        """
+        Replies with the current time in game.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the command.
+            ephemeral: (bool): Whether the response is ephemeral or not.
+        """
+        gametime = datetime.now(tz=UTC)
+        await interaction.response.send_message(content=f"{gametime.hour}:{gametime.minute}", ephemeral=ephemeral)

cogs/commands/view.py

@@ -0,0 +1,215 @@
+"""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 (
+    EventPoints,
+    Presences,
+    Votes,
+    engine,
+)
+from utils import MAX_DISCORD_MESSAGE_LENGTH, VoteType
+
+
+class ViewCog(commands.Cog, name="View Commands"):
+    """Holds the view commands."""
+
+    def __init__(self) -> None:
+        """Default constructor for ViewCog class. Does nothing."""
+
+    @nextcord.slash_command()
+    async def view(self, interaction: nextcord.Interaction) -> None:
+        """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,
+        ),
+    ) -> None:
+        """
+        View the event points.
+
+        Builds a message with the event points for the quarter that matches with quarter_name.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with the message.
+            quarter_name (str, optional): Same of quarter to autofill with. Is SlashOption.
+        """
+        # just in case
+        await interaction.response.defer(ephemeral=True)
+
+        with Session(engine) as session:
+            if quarter_name:
+                ppdf = pd.read_sql_query(
+                    sql=session.query(EventPoints).where(EventPoints.QuarterName.startswith(quarter_name)).statement,
+                    con=engine,
+                )
+            else:
+                ppdf = pd.read_sql_query(
+                    sql=session.query(EventPoints).statement,
+                    con=engine,
+                )
+
+            if ppdf.empty:
+                await interaction.followup.send(f'Quarter "{quarter_name}" is invalid.', ephemeral=True)
+                return
+
+            quarters = ppdf.groupby("QuarterName")
+            content = ""
+            for quarter in quarters.groups:
+                content += f"**{quarter}**\n"
+                unsorted_all = quarters.get_group(quarter).groupby("DiscordMember")
+                members = unsorted_all.get_group(name=True)
+
+                # there can be no non-discord members sometimes.
+                try:
+                    sorted_non_members = unsorted_all.get_group(name=False).sort_values(by="UserId")
+                except KeyError:
+                    sorted_non_members = None
+                sorted_members = members.sort_values(
+                    by="UserId",
+                    key=lambda user_ids: (
+                        [interaction.guild.get_member(int(user_id)).display_name.lower() for user_id in user_ids]
+                    ),
+                )
+                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) > MAX_DISCORD_MESSAGE_LENGTH:
+                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,
+        ),
+    ) -> None:
+        """
+        Gathers all presences from the database and responds with a message showing them.
+
+        Args:
+            interaction (nextcord.Integration):  User's interaction with the command.
+            search (str): string to search for in presences. Is SlashOption.
+        """
+        # 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.")
+    async def votes(
+        self,
+        interaction: nextcord.Interaction,
+        election_name: str = nextcord.SlashOption(
+            required=True, description="The election you want to view votes for."
+        ),
+        election_type: str = nextcord.SlashOption(
+            required=True,
+            description="The election type. Council, Discord Manager, or Clan Leader.",
+            choices=VoteType,
+        ),
+    ) -> None:
+        """
+        View all voters and who they voted for.
+
+        Takes in an election name and sends a response message to the user with a list of people who voted in that
+        election and who they voted for. Notes those tho abstained. Tells a user if the election is invalid. Uses
+        autocompletion to assist with getting elections.
+
+        Args:
+            interaction (nextcord.Interaction): User's interaction with the command.
+            election_name (str): Is SlashOption. The name of the election to view votes for.
+            election_type(str): Is SlashOption. The type of election to search for. Choice from StrEnum VoteType.
+        """
+        stmt = select(Votes).where(Votes.ElectionName == election_name).where(Votes.Type == election_type)
+
+        with Session(engine) as session:
+            # Check if election exists.
+            if session.scalar(stmt) is None:
+                await interaction.response.send_message(f"Invalid election: {election_name}.", ephemeral=True)
+                return
+
+            votes = session.scalars(stmt)
+            content = ""
+            for vote in votes:
+                content += (
+                    f"<@{vote.VoterId}> voted for <@{vote.VotedForId}>.\n"
+                    if vote.VotedForId is not None
+                    else f"<@{vote.VoterId}> abstained from voted.\n"
+                )
+
+            await interaction.response.send_message(content=content, ephemeral=True)
+
+    @votes.on_autocomplete("election_name")
+    async def election_autocomplete(self, interaction: nextcord.Interaction, election_name: str) -> None:
+        """
+        Collects all elections that start with the election string.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction with command.
+            election_name (str): String to run autocomplete on.
+        """
+        with Session(engine) as session:
+            stmt = select(Votes.ElectionName).distinct()
+            elections = session.scalars(stmt)
+
+            # if empty compare string
+            if not election_name:
+                await interaction.response.send_autocomplete(list(elections)[:25])
+                return
+
+            autofilled_elections: list[str] = [
+                election for election in elections if election.lower().startswith(election_name.lower())
+            ]
+            await interaction.response.send_autocomplete(autofilled_elections[:25])
+
+    @event_points.on_autocomplete("quarter_name")
+    async def event_points_autocomplete(self, interaction: nextcord.Interaction, quarter_name: str) -> None:
+        """
+        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(EventPoints.QuarterName).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

@@ -1,15 +1,12 @@
-"""
+"""Initializing code for all loops."""
-Initializing code for all loops.
-"""
 
 from nextcord.ext import commands
 
-from .daily_loop import DailyLoop
+from cogs.loops.bot_presence import BotPresence
+from cogs.loops.daily_loop import DailyLoop
 
 
-def setup(bot: commands.Bot):
+def setup(bot: commands.Bot) -> None:
-    """
+    """Adds functions to bot."""
-    Adds functions to bot.
+    bot.add_cog(BotPresence(bot))
-    """
-
     bot.add_cog(DailyLoop(bot))

cogs/loops/bot_presence.py

@@ -0,0 +1,38 @@
+"""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) -> None:  # noqa: ARG002
+        """Listener for Guild Join. Updated presence on guild join."""
+        await self.change_presence()
+
+    @commands.Cog.listener()
+    async def on_ready(self) -> None:
+        """Starts the loop when bot is ready."""
+        await self.bot.wait_until_ready()
+        self.periodic_change_presence.start()
+
+    @tasks.loop(minutes=5)
+    async def periodic_change_presence(self) -> None:
+        """Loops every 5 minutes and changes presence."""
+        await self.change_presence()
+
+    async def change_presence(self) -> None:
+        """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(presence))

cogs/loops/daily_loop.py

@@ -1,36 +1,122 @@
-"""
+"""Defines the daily loop that runs the Dakiny bot functions."""
-_summary_
-"""
 
-from datetime import datetime, time
+import random
+from datetime import UTC, datetime, time
+from typing import TYPE_CHECKING
 
 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 classes.election import Election
+from DakinySettings import settings
+from database_setup.sql_data_classes import UserBirthday, engine
+from main import birthday_list
+from utils import get_active_election_cycle
+
+if TYPE_CHECKING:
+    import nextcord
+
+KANDY = 239547993106284544
 
 
 class DailyLoop(commands.Cog, name="Daily Loop"):
-    """
+    """Class for performing daily functions."""
-    Class for performing daily functions.
-    """
 
     def __init__(self, bot: commands.Bot) -> None:
         self.bot = bot
-        self.election = ElectionCycle(datetime(2023, 5, 25), datetime(2023, 5, 29), datetime(2023, 5, 30), self.bot)
+        self.current_election = None
+        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
+
+    @tasks.loop(time=time(hour=0, tzinfo=timezone("UTC")))
+    async def daily_loop(self) -> None:
         """
-        Starts the loop when bot is ready.
+        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.
         """
-        print("on ready")
+        if self.current_election is None:
+            self.current_election = self.get_election()
+
+        if self.current_election is not None:
+            await self.current_election.check_date()
+            if self.current_election.election_over:
+                self.current_election = None
+
+        self.update_birthdays()
+
+        if KANDY in birthday_list:
+            # inform kandy that it is her "birthday"
+            kandy: nextcord.User = await self.bot.fetch_user(KANDY)
+            await kandy.send('Happy "Birthday"!')
+
+        await self.cakedays()
+
+    @daily_loop.before_loop
+    async def before_loop(self) -> None:
+        """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()
-        # 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")))
+        # Bot needs to know guilds to get the current cycle.
-    async def do_thing(self):
+        self.current_election = self.get_election()
-        """ """
+
-        print("loop")
+    def get_election(self) -> Election:
-        await self.election.check_date()
+        """
+        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:
+            Election: Current election cycle, None if there is no election happening.
+        """
+        cycle = get_active_election_cycle()
+
+        # prevent exception from using cycle as an Int in an array
+        if cycle is None:
+            return None
+
+        election = Election(cycle, self.bot.get_guild(settings.params.guild_id))
+
+        return election if election.active else None
+
+    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:  # noqa: S311 isn't cryptography related.
+            birthday_list.append(KANDY)
+
+        today = datetime.now(tz=UTC).date()
+        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.now(tz=UTC).date()
+        guild: nextcord.Guild = self.bot.get_guild(settings.params.guild_id)
+        announce_channel: nextcord.TextChannel = guild.get_channel(settings.channel_ids.general)
+
+        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,40 @@
+"""Defines cog for on message listener."""
+
+import nextcord
+from nextcord.ext import commands
+
+from main 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) -> None:
+        """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) -> None:
+    """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

@@ -1,8 +0,0 @@
-import os
-
-from dotenv.main import load_dotenv
-
-load_dotenv()
-
-# Discord config
-DISCORD_TOKEN = os.getenv("DISCORD_TOKEN", "")

dakiny_bot.py

@@ -1,40 +0,0 @@
-import os
-
-import nextcord
-from nextcord.ext import commands
-
-import config
-
-
-def main():
-    # Allows privledged intents for monitoring members joining, roles editing, and role assignments
-    # These need to be enabled in the developer portal as well
-    intents = nextcord.Intents.default()
-
-    # Required in order to read messages (eg. prefix commands)
-    intents.message_content = True
-
-    # To enable the guilds priveleged intent:
-    # intents.guilds = True
-
-    # To enable the members priveleged intent:
-    # intents.members = True
-
-    bot = commands.Bot(intents=intents)
-
-    # Get the modules of all cogs whose directory structure is ./cogs/<module_name>
-    for folder in os.listdir("cogs"):
-        bot.load_extension(f"cogs.{folder}")
-
-    @bot.listen()
-    async def on_ready():
-        """When Discord is connected"""
-        assert bot.user is not None
-        print(f"{bot.user.name} has connected to Discord!")
-
-    # Run Discord bot
-    bot.run(config.DISCORD_TOKEN)
-
-
-if __name__ == "__main__":
-    main()

database_setup/create_database.py

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

database_setup/database.sql

@@ -0,0 +1,62 @@
+CREATE TABLE ElectionInformation(
+    ElectionName varchar(30) not null unique,
+    ThreadId bigint unsigned not null,
+    CouncilVoteMsgId bigint unsigned,
+    HighCouncilVoteMsgId bigint unsigned,
+    CouncilNominationMsgId bigint unsigned,
+    HighCouncilNominationMsgId bigint unsigned,
+    PRIMARY KEY (ElectionName)
+);
+
+CREATE TABLE CouncilMembers(
+    ElectionName varchar(30) not null,
+    MemberId bigint unsigned not null,
+    SpeechMsgId bigint unsigned not null,
+    Elected boolean DEFAULT false,
+    DiscordManager boolean DEFAULT false,
+    ClanLeader boolean DEFAULT false,
+    DiscordManagerSpeechId bigint unsigned,
+    ClanLeaderSpeechId bigint unsigned,
+    FOREIGN KEY (ElectionName) REFERENCES ElectionInformation(ElectionName),
+    PRIMARY KEY (ElectionName, MemberId)
+);
+
+CREATE TABLE Votes(
+    ElectionName varchar(30) not null,
+    VoterId bigint unsigned not null,
+    VotedForId bigint unsigned,
+    Type varchar(14) not null DEFAULT 'council' check("Type" in ('council', 'discordmanager', 'clanleader')),
+    FOREIGN KEY (ElectionName) REFERENCES ElectionInformation(ElectionName),
+    PRIMARY KEY (ElectionName, VoterId, Type)
+);
+
+CREATE TABLE UserBirthday (
+    UserId bigint unsigned not null,
+    Birthday varchar(5) not null,
+    PRIMARY KEY (UserId)
+);
+
+CREATE TABLE Presences (
+    Id integer PRIMARY KEY,
+    Presence varchar(100) not null
+);
+
+CREATE TABLE EventPoints (
+    QuarterName varchar(30) not null,
+    UserId varchar(32) not null,
+    DiscordMember boolean not null,
+    Points int unsigned DEFAULT 0,
+    PRIMARY KEY (QuarterName, UserId)
+);
+
+CREATE TABLE Messages (
+    Path varchar(100) PRIMARY KEY,
+    Id bigint unsigned not null
+);
+
+CREATE TABLE EventPointsLimit (
+    UserId varchar(32) not null,
+    Points int unsigned DEFAULT 0,
+    Week varchar(7) not null,
+    PRIMARY KEY (UserId, Week)
+);

database_setup/pyproject.toml

@@ -0,0 +1,7 @@
+[tool.ruff]
+# Extend the `pyproject.toml` file in the parent directory...
+extend = "../pyproject.toml"
+
+[tool.ruff.lint]
+# ignore implicit-namespace-package in this directory.
+ignore = ["INP001"]

database_setup/sql_data_classes.py

@@ -0,0 +1,20 @@
+"""Simple file to set up the sqlalchemy connection to database."""
+
+from sqlalchemy import create_engine
+from sqlalchemy.ext.automap import automap_base
+
+# connect with sql alchemy and autoload schema
+URL = "sqlite+pysqlite:///database/dakiny.db"
+engine = create_engine(URL)
+Base = automap_base()
+Base.prepare(autoload_with=engine)
+
+# define the classes
+CouncilMembers = Base.classes.CouncilMembers
+ElectionInformation = Base.classes.ElectionInformation
+EventPointsLimit = Base.classes.EventPointsLimit
+Messages = Base.classes.Messages
+EventPoints = Base.classes.EventPoints
+Presences = Base.classes.Presences
+UserBirthday = Base.classes.UserBirthday
+Votes = Base.classes.Votes

main.py

@@ -0,0 +1,59 @@
+"""Main file for bot."""
+
+import logging
+import os
+
+import nextcord
+from nextcord.ext import commands
+
+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 DakinySettings import settings
+from database_setup import create_database
+
+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)
+
+
+def main() -> None:
+    """Builds and runs bot."""
+    # Allows privileged intents for monitoring members joining, roles editing, and role assignments
+    # These need to be enabled in the developer portal as well
+    intents = nextcord.Intents.default()
+
+    # Required in order to read messages (eg. prefix commands)
+    intents.message_content = True
+
+    # To enable the members privileged intent:
+    intents.members = True
+
+    bot = commands.Bot(intents=intents)
+
+    # Get the modules of all cogs whose directory structure is ./cogs/<module_name>
+    for folder in os.listdir("cogs"):
+        bot.load_extension(f"cogs.{folder}")
+
+    @bot.listen()
+    async def on_ready() -> None:
+        """When Discord is connected."""
+        assert bot.user is not None  # noqa: S101 documentation does this
+        create_database  # noqa: B018
+        bot.add_view(NominateView(bot.get_guild(settings.params.guild_id)))
+        bot.add_view(NominateHighCouncilView(bot.get_guild(settings.params.guild_id)))
+        bot.add_view(VoteView(bot.get_guild(settings.params.guild_id)))
+        bot.add_view(VoteHighcouncilView(bot.get_guild(settings.params.guild_id)))
+        print(f"{bot.user.name} has connected to Discord!")  # noqa: T201 TODO make logging to print my stuff to console
+
+    # Run Discord bot
+    bot.run(settings.params.discord_token)
+
+
+if __name__ == "__main__":
+    main()

permissions_required.txt

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

pyproject.toml

@@ -0,0 +1,134 @@
+[tool.poetry]
+name = "dakiny-bot"
+version = "0.1.0"
+description = "Dakiny's Discord Bot."
+authors = ["imcompiling <[email protected]>"]
+readme = "README.md"
+package-mode = false
+
+[tool.poetry.dependencies]
+python = "^3.12"
+gitpython = "^3.1.43"
+fastapi = "^0.111.0"
+nextcord = "^2.6.0"
+pandas = "^2.2.2"
+pytz = "^2024.1"
+sqlalchemy = "^2.0.30"
+aiofiles = "^23.2.1"
+setuptools = "^70.0.0"
+dataclass-wizard = "^0.22.3"
+
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.6.3"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+    "dakiny-messages",    # Don't need to lint this git repo.
+]
+
+# Same as Black.
+line-length = 120
+indent-width = 4
+
+# Assume Python 3.8
+target-version = "py312"
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["ALL"]
+ignore = [
+    "ANN101",
+    "B008",   # I build SlashOptions as arguments.
+    "COM812",
+    "COM819",
+    "D107",   # don't want docstrings on init functions
+    "D203",
+    "D206",
+    "D212",
+    "D300",
+    "E111",
+    "E114",
+    "E117",
+    "ISC001",
+    "ISC002",
+    "PD011",  # doesn't like me using '.values' on embeds....
+    "Q000",
+    "Q001",
+    "Q002",
+    "Q003",
+    "W191",
+]
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.flake8-annotations]
+mypy-init-return = true
+
+[tool.ruff.format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = true
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"

requirements.txt

@@ -1,3 +0,0 @@
-nextcord==2.4.2
-python-dotenv==1.0.0
-pytz==2022.7.1

runtime.txt

@@ -1 +0,0 @@
-python-3.10.4

utils.py

@@ -0,0 +1,540 @@
+"""File contains util functions."""
+
+import calendar
+import os
+from collections.abc import Sequence
+from datetime import UTC, datetime
+from enum import StrEnum
+from pathlib import Path
+
+import aiofiles
+import nextcord
+from sqlalchemy import select, true, update
+from sqlalchemy.orm import Session
+
+from DakinySettings import settings
+from database_setup.sql_data_classes import (
+    CouncilMembers,
+    EventPoints,
+    EventPointsLimit,
+    Messages,
+    Votes,
+    engine,
+)
+
+NOMINEE_SPLITTER = "========================================\n\n"
+REPO_DIR = "./dakiny-messages"
+MESSAGES_DIR = f"{REPO_DIR}/messages"
+TEMPLATES_DIR = f"{REPO_DIR}/message_templates"
+MAX_DISCORD_MESSAGE_LENGTH = 2000
+GUILDS = [1000247361639030804, 239758371358638080]
+
+VoteType = StrEnum("VoteType", ["COUNCIL", "DISCORDMANAGER", "CLANLEADER"])
+
+
+def get_datetime(day: str) -> datetime:
+    """
+    Takes in a string month and day and returns a datetime object of that Month/Day this year.
+
+    Args:
+        day (str): Month/Day in that format.
+
+    Returns:
+        datetime: Datetime representation of Month/Day.
+    """
+    today = datetime.now(tz=UTC).date()
+    year = today.year
+    month = int(day.split("/")[0])
+    day = int(day.split("/")[1])
+
+    # ensure that year rolls over if current month is December and the next month is less than 12.
+    if today.month == calendar.DECEMBER and month < calendar.OCTOBER:
+        year += 1
+
+    if today.month == calendar.JANUARY and month > calendar.MARCH:
+        year -= 1
+
+    return datetime(year, month, day, tzinfo=UTC)
+
+
+def get_election_name() -> str:
+    """
+    Builds the unique name of the current election cycle.
+
+    Returns:
+        str: the name of the election cycle
+    """
+    cycle = get_active_election_cycle()
+    current_cycle = settings.election_cycles[cycle]
+    return f"vote-{get_datetime(current_cycle.term_start).year}-{current_cycle.name}"
+
+
+def get_quarter_name() -> str:
+    """
+    Builds the name of the current cycle/quarter.
+
+    Returns:
+        str: the name of the cycle.
+    """
+    cycle = get_quarter_cycle()
+    current_cycle = settings.election_cycles[cycle]
+
+    return f"{get_datetime(current_cycle.term_start).year}-{current_cycle.name}"
+
+
+def get_active_election_cycle() -> int:
+    """
+    Returns index for active election. An election is considered active between the election start and the term start.
+
+    Returns:
+        int: cycle index for active election. None for no active cycle
+    """
+    today = datetime.now(tz=UTC)
+
+    for cycle, election in enumerate(settings.election_cycles):
+        if (
+            today.date() >= get_datetime(election.election_start).date()
+            and today.date() <= get_datetime(election.term_start).date()
+        ):
+            return cycle
+
+    # It isn't a current election, get the quarter
+    return get_quarter_cycle()
+
+
+def get_quarter_cycle() -> int:
+    """
+    Returns the index for the current cycle/quarter. Defined as between term start and end.
+
+    Can return None if entire year isn't covered by cycles.
+
+    Returns:
+        int: cycle index for current cycle.
+    """
+    today = datetime.now(tz=UTC)
+    for cycle, election in enumerate(settings.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(guild: nextcord.Guild) -> str:
+    """
+    Creates a string that contains all nominees and their votes to be sent as a discord message.
+
+    Args:
+        guild (nextcord.Guild): The guild object. Used to get display names for sorting.
+
+    Returns:
+        str: String that contains all nominees and their votes.
+    """
+    votes: dict[int, int] = {}
+
+    election_name = get_election_name()
+
+    with Session(engine) as session:
+        stmt = select(CouncilMembers).where(CouncilMembers.ElectionName == election_name)
+
+        for nominee in sorted(
+            session.scalars(stmt),
+            key=lambda nominee: guild.get_member(nominee.MemberId).display_name.lower(),
+        ):
+            votes[nominee.MemberId] = 0
+
+        stmt = select(Votes).where(Votes.ElectionName == election_name).where(Votes.Type == VoteType.COUNCIL)
+
+        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(guild: nextcord.Guild) -> str:
+    """
+    Creates a string that contains all high council nominees and their votes to be sent as a discord message.
+
+    Args:
+        guild (nextcord.Guild): The guild object. Used to get display names for sorting.
+
+    Returns:
+        str: String that contains all nominees and their votes.
+    """
+    cl_votes: dict[int, int] = {}
+    dm_votes: dict[int, int] = {}
+
+    election_name = get_election_name()
+
+    with Session(engine) as session:
+        stmt = (
+            select(CouncilMembers)
+            .where(CouncilMembers.ElectionName == election_name)
+            .filter(CouncilMembers.ClanLeaderSpeechId.is_not(None))
+        )
+
+        for nominee in sorted(
+            session.scalars(stmt),
+            key=lambda nominee: guild.get_member(nominee.MemberId).display_name.lower(),
+        ):
+            cl_votes[nominee.MemberId] = 0
+
+        stmt = select(Votes).where(Votes.ElectionName == election_name).where(Votes.Type == VoteType.CLANLEADER)
+
+        for vote in session.scalars(stmt):
+            if vote.VotedForId is not None:
+                cl_votes[vote.VotedForId] += 1
+
+        stmt = (
+            select(CouncilMembers)
+            .where(CouncilMembers.ElectionName == election_name)
+            .filter(CouncilMembers.DiscordManagerSpeechId.is_not(None))
+        )
+
+        for nominee in sorted(
+            session.scalars(stmt),
+            key=lambda nominee: guild.get_member(nominee.MemberId).display_name.lower(),
+        ):
+            dm_votes[nominee.MemberId] = 0
+
+        stmt = select(Votes).where(Votes.ElectionName == election_name).where(Votes.Type == VoteType.DISCORDMANAGER)
+
+        for vote in session.scalars(stmt):
+            if vote.VotedForId is not None:
+                dm_votes[vote.VotedForId] += 1
+
+    # build the votes string
+    votes_str: str = "Clan Leader Votes\n===================="
+    votes_str += user_vote_str(cl_votes)
+
+    votes_str += "\n\nDiscord Manager Votes\n===================="
+    votes_str += user_vote_str(dm_votes)
+
+    return votes_str
+
+
+def user_vote_str(votes: dict[int, int]) -> str:
+    """
+    Creates the string representing how many votes each user has.
+
+    Args:
+        votes (dict[int, int]): Dict of all users and how many votes they have.
+
+    Returns:
+        str: The string showing names and number of votes.
+    """
+    ret_str: str = ""
+
+    for user_id, num_votes in votes.items():
+        ret_str += f"\n<@{user_id}>: {'☑️' * num_votes}"
+    return ret_str
+
+
+def decorate_nomination(user_id: int, speech: str) -> str:
+    """
+    Decorates a nomination speech so that it sits within multiple speeches better.
+
+    Args:
+        user_id (int): ID of user sending the speech
+        speech (str): Speech from the user
+
+    Returns:
+        str: Decorated speech
+    """
+    msg = f"**Clan Council Nominee: <@{user_id}>**\n"
+    msg += NOMINEE_SPLITTER
+    msg += speech
+
+    return msg
+
+
+def decorate_cl_nomination(user_id: int, speech: str) -> str:
+    """
+    Decorates a nomination speech so that it sits within multiple speeches better.
+
+    Args:
+        user_id (int): ID of user sending the speech
+        speech (str): Speech from the user
+
+    Returns:
+        str: Decorated speech
+    """
+    msg = f"**Clan Leader Nominee: <@{user_id}>**\n"
+    msg += NOMINEE_SPLITTER
+    msg += speech
+
+    return msg
+
+
+def decorate_dm_nomination(user_id: int, speech: str) -> str:
+    """
+    Decorates a nomination speech so that it sits within multiple speeches better.
+
+    Args:
+        user_id (int): ID of user sending the speech
+        speech (str): Speech from the user
+
+    Returns:
+        str: Decorated speech
+    """
+    msg = f"**Discord Manager Nominee: <@{user_id}>**\n"
+    msg += NOMINEE_SPLITTER
+    msg += speech
+
+    return msg
+
+
+def record_event_points(users: Sequence[str], add_points: int, *, is_member: bool) -> None:
+    """
+    Adds event 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. Can be used for hosting or participating.
+
+    Args:
+        users (Sequence[int]): users that participated and need points.
+        add_points (int): number of points to add
+        is_member (bool): whether the users are a discord member or not
+    """
+    quarter_name = get_quarter_name()
+    with Session(engine) as session:
+        for user in users:
+            stmt = select(EventPoints).where(EventPoints.UserId == user).where(EventPoints.QuarterName == quarter_name)
+
+            points = session.scalar(stmt)
+            if points is None:
+                add_points = get_allowed_points(session, settings.event_settings.weekly_limit, user, add_points)
+                new_points = EventPoints(
+                    QuarterName=quarter_name,
+                    UserId=user,
+                    DiscordMember=is_member,
+                    Points=add_points,
+                )
+                session.add(new_points)
+            else:
+                add_points = get_allowed_points(session, settings.event_settings.weekly_limit, user, add_points)
+                points.Points += add_points
+
+        session.commit()
+
+
+def get_allowed_points(session: Session, points_limit: int, user: str, points: int) -> int:
+    """
+    Gets the maximum number of points a user can be given.
+
+    Searches how many points they have been given
+    this week and subtracts that from the weekly limit. If under, returns up to "points" number of points (will not
+    go over points_limit) otherwise returns 0. Updates the limit object or creates a new one if one isn't found.
+
+    Args:
+        session (Session): Open connection to database.
+        points_limit (int): Maximum number of points a user can be given in a week.
+        user (str): user to be given points. Used to check a user's limit.
+        points (int): maximum number of points to give to user.
+
+    Returns:
+        int: how many points are allowed to be given to the user.
+    """
+    # check for limit
+    today = datetime.now(tz=UTC).date()
+    this_week = f"{today.isocalendar().year}-{today.isocalendar().week}"
+    stmt = select(EventPointsLimit).where(EventPointsLimit.UserId == user).where(EventPointsLimit.Week == this_week)
+
+    # if under limit, can add up to however many points would make the current limit equal to the
+    # allowed limit.
+    limit = session.scalar(stmt)
+    if limit is None:
+        new_limit = EventPointsLimit(UserId=user, Points=points, Week=this_week)
+        add_points = points
+        session.add(new_limit)
+    else:
+        add_points = points if limit.Points + points <= points_limit else (max(0, points_limit - limit.Points))
+        limit.Points += add_points
+
+    session.commit()
+
+    return add_points
+
+
+async def update_clan_messages(guild: nextcord.Guild, channel_updates: Sequence[str]) -> None:
+    """
+    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 every 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.
+        channel_updates: (Sequence[str]): a sequence of the channels to update.
+    """
+    dirs = [dir_name for dir_name in channel_updates if Path(f"{MESSAGES_DIR}/{dir_name}").is_dir()]
+
+    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}"
+                async with aiofiles.open(file_path, encoding="utf8") as reader:
+                    await edit_clan_message(
+                        session, channel, message_name, await reader.read(MAX_DISCORD_MESSAGE_LENGTH)
+                    )
+
+
+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,
+) -> None:
+    """
+    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) -> None:
+    """
+    Gets the winners of the elections and updates the permanent message that states the current council.
+
+    Args:
+        guild (nextcord.Guild): Guild object that to use to get channel.
+    """
+    clan_info_channel: nextcord.TextChannel = await guild.fetch_channel(settings.channel_ids.clan_info)
+
+    election_name = get_election_name()
+    with Session(engine) as session:
+        stmt = (
+            select(CouncilMembers.MemberId)
+            .where(CouncilMembers.ElectionName == election_name)
+            .where(CouncilMembers.DiscordManager == true())
+        )
+        discord_manager = session.scalar(stmt)
+        stmt = (
+            select(CouncilMembers.MemberId)
+            .where(CouncilMembers.ElectionName == election_name)
+            .where(CouncilMembers.ClanLeader == true())
+        )
+        clan_leader = session.scalar(stmt)
+        stmt = (
+            select(CouncilMembers.MemberId)
+            .where(CouncilMembers.ElectionName == election_name)
+            .where(CouncilMembers.Elected == true())
+        )
+
+        council_member_ids = sorted(
+            session.scalars(stmt), key=lambda user_id: guild.get_member(user_id).display_name.lower()
+        )
+
+        council_members_strs = [
+            f"<@{user_id}>" for user_id in council_member_ids if user_id not in (discord_manager, clan_leader)
+        ]
+
+        quarter = get_quarter_name()
+
+        async with aiofiles.open(f"{TEMPLATES_DIR}/council_members.txt", encoding="utf8") as file:
+            message = await 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)