Merge branch '82-uv'

dakiny_bot/classes/election.py

@@ -0,0 +1,390 @@
+"""Contains the election cycle class."""
+
+import collections
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+import nextcord
+from sqlalchemy import select, true, update
+from sqlalchemy.orm import Session
+
+from dakiny_bot.classes.nominate_highcouncil_views import NominateHighCouncilView
+from dakiny_bot.classes.nominate_views import NominateView
+from dakiny_bot.classes.voting_highcouncil_views import VoteHighcouncilView
+from dakiny_bot.classes.voting_views import VoteView
+from dakiny_bot.DakinySettings import settings
+from dakiny_bot.database.sql_data_classes import (
+    CouncilMembers,
+    ElectionInformation,
+    Votes,
+    engine,
+)
+from dakiny_bot.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(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)

dakiny_bot/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

dakiny_bot/classes/nominate_highcouncil_views.py

@@ -0,0 +1,229 @@
+"""Contains various views to be used in the high council nomination process."""
+
+import nextcord
+from nextcord.interactions import Interaction
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from dakiny_bot.DakinySettings import settings
+from dakiny_bot.database.sql_data_classes import CouncilMembers, engine
+from dakiny_bot.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))

dakiny_bot/classes/nominate_views.py

@@ -0,0 +1,124 @@
+"""Contains various views to be used in the nomination process."""
+
+import nextcord
+from nextcord.interactions import Interaction
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from dakiny_bot.DakinySettings import settings
+from dakiny_bot.database.sql_data_classes import CouncilMembers, engine
+from dakiny_bot.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))

dakiny_bot/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"]

dakiny_bot/classes/voting_highcouncil_views.py

@@ -0,0 +1,237 @@
+"""Contains various views to be used while voting for high council. Controls the logic when performing the vote."""
+
+import nextcord
+from nextcord import SelectOption
+from nextcord.interactions import Interaction
+from sqlalchemy import exc, select, update
+from sqlalchemy.orm import Session
+
+from dakiny_bot.DakinySettings import settings
+from dakiny_bot.database.sql_data_classes import (
+    CouncilMembers,
+    ElectionInformation,
+    Votes,
+    engine,
+)
+from dakiny_bot.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,
+        )

dakiny_bot/classes/voting_views.py

@@ -0,0 +1,147 @@
+"""Contains various views to be used while voting. Controls the logic when performing the vote."""
+
+import nextcord
+from nextcord import SelectOption
+from nextcord.interactions import Interaction
+from sqlalchemy import exc, select, update
+from sqlalchemy.orm import Session
+
+from dakiny_bot.DakinySettings import settings
+from dakiny_bot.database.sql_data_classes import (
+    CouncilMembers,
+    ElectionInformation,
+    Votes,
+    engine,
+)
+from dakiny_bot.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(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,
+        )