Daily loop is complete. Properly maintains the current election.

This reverts commit a52979a847.

.gitea/workflows/build_develop.yml

@@ -13,6 +13,6 @@ jobs:
       - name: Install Docker
         uses: https://github.com/papodaca/install-docker-action@v1
       - 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:develop .
       - name: Push Docker Image
-        run: docker push viker.cheezers.net:5000/dakiny-bot:develop
+        run: docker push gitea.cheezers.org/imcompiling/dakiny-bot:develop

.gitea/workflows/build_latest.yml

@@ -15,6 +15,6 @@ jobs:
       - name: Install Docker
         uses: https://github.com/papodaca/install-docker-action@v1
       - 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

.gitignore

@@ -137,3 +137,6 @@ deleted_backups/
 highscores_data/
 TODO.txt
 sql_tester.py
+conf
+outputs
+dakiny.db

README.md

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

bot_messages/council_members.txt

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

bot_messages/election_announcement.txt

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

bot_messages/highcouncil_election.txt

@@ -0,0 +1,13 @@
+`Leadership Elections - candidacy time`
+
+
+<@&{clan_council_elect_role_id}>, welcome. We are starting the second part of our elections.  On {highcouncil_election_announce} this channel will be open to write for all of you. Everyone else will be able to read this channel, but not write in it. Only members of the  Clan Council Elected (CCE) can vote now. Any votes from others will be annulled.
+
+From {highcouncil_election_announce} to {highcouncil_election_start}, you will be able to announce your candidacy for High Council. The positions are:
+ Clan Leader
+ Discord Server Manager
+
+Each member of the CCE can cast one for each category by using the emotes:  <:Rank_Owner:479008325137072155>  for Clan Leader and <:Rank_Deputy:479008295319896064>  for Discord Server Manager.
+If needed, the icon 🤷 can be used to abstain to vote in any or both categories and it should be apply to all candidates of that category.
+
+Votes can be cast until the {highcouncil_election_end}, so we can announce and have everyone set up to start the term by {term_start}.

bot_messages/highcouncil_vote.txt

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

bot_messages/vote_start.txt

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

classes/election_cycle.py

@@ -5,7 +5,12 @@ Contains the election cycle class
 from datetime import datetime, timedelta
 
 import nextcord
-from nextcord.ext import commands
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from config import DakinyConfig
+from database.sql_data_classes import ElectionInformation, engine
+from utils import get_datetime
 
 
 class ElectionCycle:
@@ -14,7 +19,7 @@ class ElectionCycle:
     the cycle.
     """
 
-    def __init__(self, election_start: datetime, term_start: datetime, term_end: datetime, bot) -> None:
+    def __init__(self, cycle: int, config: DakinyConfig, guild: nextcord.Guild) -> None:
         """
         Generates all dates relevant to the election cycle from input election start, term start and end dates.
 
@@ -24,79 +29,204 @@ class ElectionCycle:
             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
+        self.config: DakinyConfig = config
+        self.cycle = cycle
+        self.elecion_cycle = self.config.election_cycles[self.cycle]
+        self.election_start: datetime = get_datetime(self.elecion_cycle.election_start)
+        self.term_start: datetime = get_datetime(self.elecion_cycle.term_start)
+        self.term_end: datetime = get_datetime(self.elecion_cycle.term_end)
+        self.voting_start: datetime = get_datetime(self.elecion_cycle.voting_start)
+        self.voting_end: datetime = get_datetime(self.elecion_cycle.voting_end)
+        self.highcouncil_election_announce: datetime = self.voting_end + timedelta(days=1)
+        self.highcouncil_election_start: datetime = self.highcouncil_election_announce + timedelta(days=3)
+        self.highcouncil_election_end: datetime = self.term_start - timedelta(days=1)
+        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 open("bot_messages/election_announcement.txt", mode="r", encoding="utf8") as file:
+            message = file.read()
+
+            next_election = get_datetime(self.config.election_cycles[(self.cycle + 1) % 4].election_start)
+
+            message = message.format(
+                clan_council_id=self.config.params.clan_council_role_id,
+                high_council_id=self.config.params.high_council_role_id,
+                election_start_date=self.election_start.strftime("%B %d"),
+                term_start_date=self.term_start.strftime("%B %d"),
+                term_end_date=self.term_end.strftime("%B %d"),
+                voting_start_date=self.voting_start.strftime("%B %d"),
+                voting_end_date=self.voting_end.strftime("%B %d"),
+                highcouncil_election_date=self.highcouncil_election_start.strftime("%B %d"),
+                next_election_start_date=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 open("bot_messages/highcouncil_election.txt", mode="r", encoding="utf8") as file:
+            message = file.read()
+
+            return message.format(
+                clan_council_elect_role_id=self.config.params.clan_council_elect_role_id,
+                highcouncil_election_announce=self.highcouncil_election_announce.strftime("%B %d"),
+                highcouncil_election_start=self.highcouncil_election_start.strftime("%B %d"),
+                highcouncil_election_end=self.highcouncil_election_end.strftime("%B %d"),
+                term_start_date=self.term_start.strftime("%B %d"),
+            )
+
+    def build_highcouncil_vote_start(self) -> str:
+        """
+        Builds the message to announce that highcouncil voting has started.
+
+        Returns:
+            str: Message to send.
+        """
+
+        with open("bot_messages/highcouncil_vote.txt", mode="r", encoding="utf8") as file:
+            message = file.read()
+
+            return message.format(
+                clan_council_elect_role_id=self.config.params.clan_council_elect_role_id,
+                term_start_date=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 open("bot_messages/vote_start.txt", mode="r", encoding="utf8") as file:
+            message = file.read()
+            vote_end: datetime = get_datetime(self.config.election_cycles[self.cycle].voting_end)
+
+            return message.format(
+                clan_member_id=self.config.params.clan_member_role_id,
+                voting_emote_id=self.config.params.voting_emote_id,
+                voting_end_date=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.today()
-        print("checking the date")
 
         # check all dates if action is needed
-        if today.date() == self._election_start.date():
+        if today.date() == self.election_start.date():
             await self.election_start_action()
-        elif today.date() == self._voting_start.date():
+        elif today.date() == self.voting_start.date():
             await self.voting_end_action()
-        elif today.date() == self._voting_end.date():
+        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():
+        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()
-        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")
+        # create new channel for election
+        category: nextcord.CategoryChannel = self.guild.get_channel(self.config.params.active_category_id)
+        quarter_name: str = self.get_election_cycle_name()
+
+        # create new entry into database.
+        election_channel: nextcord.TextChannel = await category.create_text_channel(quarter_name)
+        with Session(engine) as session:
+            new_cycle = ElectionInformation(ElectionCycle=quarter_name, ElectionChannel=election_channel.id)
+            session.add(new_cycle)
+            session.commit()
+
+        # post message announcing election
+        # election start message is returned as an array of string because it is too long. send each string
+        # individually.
+        messages = self.build_election_announcement()
+        for message in messages:
+            await election_channel.send(message)
 
     async def voting_start_action(self) -> None:
         """
-        Performs required actions for when voting for candidates starts.
+        Sends message informing members that voting has started.
+        Removes write permission from the general clan member role.
+        Adds the voting emote to all messages not sent by the vote. (This is temporary until voting is managed.)
         """
-        print("Voting has started")
-        await self.message_me("Voting has started")
+        message = self.build_vote_start()
+        clan_member_role: nextcord.Role = self.guild.get_role(self.config.params.clan_member_role_id)
+        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+        await election_channel.send(message)
+        await election_channel.set_permissions(clan_member_role, send_messages=False)
 
     async def voting_end_action(self) -> None:
         """
         Performs required actions for when voting time has ended.
         """
-        print("voting has ended")
-        await self.message_me("voting has ended")
+        message = self.build_highcouncil_election_announce()
+        council_elect_role: nextcord.Role = self.guild.get_role(self.config.params.clan_council_elect_role_id)
+        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+        await election_channel.send(message)
+        await election_channel.set_permissions(council_elect_role, send_messages=True)
 
-    async def highcouncil_election_action(self) -> None:
+    async def highcouncil_election_start_action(self) -> None:
         """
         Performs required actions for when the highcouncil is elected.
         """
-        print("Highcouncil election has started.")
-        await self.message_me("Highcouncil election has started.")
+
+        message = self.build_highcouncil_vote_start()
+        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+        await election_channel.send(message)
 
     async def term_start_action(self) -> None:
-        msg: str = "the term has started"
-        print(msg)
-        self.message_me(msg)
-
-    async def term_end_action(self):
-        msg: str = "the term has ended"
-        print(msg)
-        self.message_me(msg)
-
-    async def message_me(self, msg: str):
         """
-        message a string to me
+        Moves the election channel into the archive category.
         """
-        imcompiling: nextcord.User = await self._bot.fetch_user(206602713511886849)
-        await imcompiling.send(msg)
+
+        self.election_over = True
+        election_channel: nextcord.TextChannel = self.guild.get_channel(self.get_election_info().ElectionChannel)
+        archive: nextcord.CategoryChannel = self.guild.get_channel(self.config.params.archive_channel_group_id)
+
+        await election_channel.move(beginning=True, category=archive)
+
+    def get_election_cycle_name(self) -> str:
+        """
+        Builds the unique name of the current election cycle
+
+        Returns:
+            str: the name of the election cycle
+        """
+
+        return f"{self.election_start.year} {self.elecion_cycle.name} election"
+
+    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.ElectionCycle == self.get_election_cycle_name()
+            )
+            return session.scalar(stmt)

cogs/commands/__init__.py

@@ -0,0 +1,16 @@
+"""
+Cog loader. Adds all command cogs to the bot.
+"""
+
+from nextcord.ext import commands
+
+from cogs.commands.test import TestCog
+
+
+# This function will be called when this extension is loaded.
+# It is necessary to add these functions to the bot.
+def setup(bot: commands.Bot):
+    """
+    Adds all command classes to bot.
+    """
+    bot.add_cog(TestCog(bot))

cogs/commands/test.py

@@ -0,0 +1,66 @@
+"""
+Commands for testing.
+"""
+
+import nextcord
+from nextcord.ext import commands
+
+from classes.election_cycle import ElectionCycle
+
+
+class TestCog(commands.Cog, name="Test commands."):
+    """
+    Class holds commands for testing.
+    """
+
+    def __init__(self, bot) -> None:
+        """
+        Default constructor for HelpCog class. Does nothing.
+        """
+        self.bot = bot
+
+    @nextcord.slash_command()
+    async def test(self, interaction: nextcord.Interaction):
+        """
+        Parent slash command for help. Never called.
+        """
+
+    @test.subcommand()
+    async def msg_builder(self, interaction: nextcord.Interaction):
+        """
+        Tests the message builder.
+
+        Args:
+            interaction (nextcord.Interaction): Interaction that invoked the command.
+        """
+
+        cycle = ElectionCycle(0, self.bot)
+
+        message = cycle.build_election_announcement()
+
+        # doesn't tell discord that the message was responded to. Is a test command so I don't really care atm.
+        for m in message:
+            await interaction.channel.send(content=m)
+
+    @test.subcommand()
+    async def election_start(self, interaction: nextcord.Interaction):
+        """
+        idc
+
+        Args:
+            interaction (nextcord.Interaction): _description_
+        """
+
+        cycle = ElectionCycle(0, self.bot)
+        await cycle.election_start_action()
+
+    @test.subcommand()
+    async def voting_start(self, interaction: nextcord.Interaction):
+        """
+        tests the voting start action
+
+        Args:
+            interaction (nextcord.Interaction): _description_
+        """
+        cycle = ElectionCycle(0, self.bot)
+        await cycle.voting_start_action()

cogs/loops/daily_loop.py

@@ -1,5 +1,5 @@
 """
-_summary_
+Defines the daily loop that runs the Dakiny bot functions.
 """
 
 from datetime import datetime, time
@@ -8,6 +8,8 @@ from nextcord.ext import commands, tasks
 from pytz import timezone
 
 from classes.election_cycle import ElectionCycle
+from config import DakinyConfig
+from utils import get_datetime
 
 
 class DailyLoop(commands.Cog, name="Daily Loop"):
@@ -17,20 +19,51 @@ class DailyLoop(commands.Cog, name="Daily Loop"):
 
     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 = self.get_current_cycle()
 
     @commands.Cog.listener()
     async def on_ready(self):
         """
         Starts the loop when bot is ready.
         """
-        print("on ready")
         await self.bot.wait_until_ready()
         # pylint doesn't recognize that periodic_update_guild_data is subclassed from tasks.loop.
-        await self.do_thing.start()  # pylint: disable=no-member
+        await self.daily_loop.start()  # pylint: disable=no-member
 
     @tasks.loop(time=time(hour=0, tzinfo=timezone("GMT")))
-    async def do_thing(self):
-        """ """
-        print("loop")
-        await self.election.check_date()
+    async def daily_loop(self):
+        """
+        Runs daily. Checks if the current election is None. If so, checks if there is an active election. If there is
+        an active election, runs the check_date() function for the election to perform actions. Finally checks if the
+        election is over to delete the current election object.
+        """
+
+        if self.current_election is None:
+            self.current_election = self.get_current_cycle()
+
+        if self.current_election is not None:
+            await self.current_election.check_date()
+            if self.current_election.election_over:
+                self.current_election = None
+
+    def get_current_cycle(self) -> ElectionCycle:
+        """
+        Creates an object for the current election cycle if one is active. An election is considered active
+        between the election start and the term start.
+
+        Returns:
+            ElectionCycle: Current election cycle, None if there is no election happening.
+        """
+
+        today = datetime.today()
+        config: DakinyConfig = self.bot.config
+        current_election = None
+
+        for cycle, election in enumerate(config.election_cycles):
+            if (
+                today.date() > get_datetime(election.election_start).date()
+                and today.date() < get_datetime(election.term_start).date()
+            ):
+                current_election = ElectionCycle(cycle, config, self.bot.get_guild(config.params.guild_id))
+
+        return current_election

config.py

@@ -1,8 +1,47 @@
-import os
+"""
+File contains classes defining the Hydra configuraton structure.
+"""
+from dataclasses import dataclass
 
-from dotenv.main import load_dotenv
 
-load_dotenv()
+@dataclass
+class Params:
+    """
+    Class defines the various configuration parameters.
+    """
 
-# Discord config
-DISCORD_TOKEN = os.getenv("DISCORD_TOKEN", "")
+    active_category_id: int
+    annoucement_category_id: int
+    archive_channel_group_id: int
+    clan_council_elect_role_id: int
+    clan_council_role_id: int
+    clan_info_channel_id: int
+    clan_member_role_id: int
+    discord_token: str
+    guild_id: int
+    high_council_role_id: int
+    voting_emote_id: str
+
+
+@dataclass
+class ElectionCycle:
+    """
+    Class defines relevant election dates.
+    """
+
+    election_start: str
+    name: str
+    term_end: str
+    term_start: str
+    voting_end: str
+    voting_start: str
+
+
+@dataclass
+class DakinyConfig:
+    """
+    Class defines all configs required for Dakiny Bot.
+    """
+
+    election_cycles: list[ElectionCycle]
+    params: Params

dakiny_bot.py

@@ -1,12 +1,20 @@
 import os
+import sys
 
+import hydra
 import nextcord
+from hydra.core.config_store import ConfigStore
 from nextcord.ext import commands
 
-import config
+import database.create_database as create_database
+from config import DakinyConfig
+
+cs = ConfigStore.instance()
+cs.store(name="dakiny_config", node=DakinyConfig)
 
 
-def main():
+@hydra.main(config_path="conf", config_name="config")
+def main(cfg: DakinyConfig):
     # 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()
@@ -21,6 +29,7 @@ def main():
     # intents.members = True
 
     bot = commands.Bot(intents=intents)
+    bot.config = cfg
 
     # Get the modules of all cogs whose directory structure is ./cogs/<module_name>
     for folder in os.listdir("cogs"):
@@ -30,11 +39,13 @@ def main():
     async def on_ready():
         """When Discord is connected"""
         assert bot.user is not None
+        create_database  # pylint: disable=pointless-statement
         print(f"{bot.user.name} has connected to Discord!")
 
     # Run Discord bot
-    bot.run(config.DISCORD_TOKEN)
+    bot.run(bot.config.params.discord_token)
 
 
 if __name__ == "__main__":
+    sys.argv.append("hydra.job.chdir=False")
     main()

database/create_database.py

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

database/database.sql

@@ -0,0 +1,27 @@
+-- CREATE DATABASE dakiny;
+-- use dakiny;
+
+CREATE TABLE ElectionInformation(
+    ElectionCycle varchar(30) not null unique,
+    ElectionChannel bigint unsigned not null,
+    PRIMARY KEY (ElectionCycle)
+);
+
+CREATE TABLE CouncilMembers(
+    ElectionCycle varchar(30) not null unique,
+    MemberId bigint unsigned not null,
+    Elected boolean DEFAULT false,
+    HighCouncilElect boolean DEFAULT false,
+    DiscordManager boolean DEFAULT false,
+    ClanLeader boolean DEFAULT false,
+    FOREIGN KEY (ElectionCycle) REFERENCES ElectionInformation(ElectionCycle),
+    PRIMARY KEY (ElectionCycle, MemberId)
+);
+
+CREATE TABLE Votes(
+    ElectionCycle varchar(30) not null unique,
+    VoterId bigint unsigned not null,
+    VotedForId bigint unsigned not null,
+    FOREIGN KEY (ElectionCycle) REFERENCES ElectionInformation(ElectionCycle),
+    PRIMARY KEY (ElectionCycle, VoterId)
+);

database/sql_data_classes.py

@@ -0,0 +1,16 @@
+"""
+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:///dakiny.db"
+engine = create_engine(URL)
+Base = automap_base()
+Base.prepare(autoload_with=engine)
+
+# define the classes
+ElectionInformation = Base.classes.ElectionInformation
+CouncilMembers = Base.classes.CouncilMembers
+Votes = Base.classes.Votes

permissions_required.txt

@@ -0,0 +1,4 @@
+Discord permissions required for bot to operate:
+
+manage channels
+manage roles

requirements.txt

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

utils.py

@@ -0,0 +1,26 @@
+"""
+File contains util functions.
+"""
+
+from datetime import datetime
+
+
+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.
+    """
+    year = datetime.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 datetime.today().month == 12 & month < 12:
+        year += 1
+
+    return datetime(year, month, day)