Heimdallr/commands/admin.py

import logging
from typing import Optional
from naff import (
    Client,
    Extension,
    slash_command,
    slash_option,
    OptionTypes,
    Permissions,
    InteractionContext,
    Embed,
    EmbedField,
    GuildChannel,
    ChannelTypes,
)

from database import GuildSettings as GuildSettingsModel, JoinLeave as JoinLeaveModel


class Admin(Extension):
    def __init__(self, client: Client) -> None:
        self.client = client

    @slash_command(
        name="adm",
        sub_cmd_name="list",
        sub_cmd_description="List all settings for this guild",
        dm_permission=False,
        default_member_permissions=Permissions.MANAGE_GUILD,
    )
    async def adm_list(self, ctx: InteractionContext) -> None:
        guild_settings: Optional[GuildSettingsModel]
        guild_settings, _ = GuildSettingsModel.get_or_create(guild_id=ctx.guild_id)
        joinleave_settings: Optional[GuildSettingsModel]
        joinleave_settings, _ = JoinLeaveModel.get_or_create(guild_id=ctx.guild_id)
        embed = Embed(
            title="Settings for {}".format(ctx.guild.name),
            fields=[
                EmbedField(
                    name="**Admin channel**",
                    value=(
                        await ctx.guild.fetch_channel(guild_settings.admin_channel)
                    ).mention
                    if guild_settings.admin_channel is not None
                    else "Not set",
                ),
                EmbedField(
                    name="**Name filter**",
                    value=str(guild_settings.use_name_filter)
                    if guild_settings.use_name_filter is not None
                    else "Not set (disabled)",
                ),
                EmbedField(
                    name="**Gatekeep**",
                    value=str(guild_settings.use_gatekeep)
                    if guild_settings.use_gatekeep is not None
                    else "Not set (disabled)",
                ),
                EmbedField(
                    name="**Join/leave messages channel**",
                    value=(
                        await ctx.guild.fetch_channel(
                            joinleave_settings.message_channel
                        )
                    ).mention
                    if joinleave_settings.message_channel is not None
                    else "Not set",
                ),
                EmbedField(
                    name="**Join messages enabled**",
                    value=str(joinleave_settings.join_message_enabled)
                    if joinleave_settings.join_message_enabled is not None
                    else "Not set (disabled)",
                ),
                EmbedField(
                    name="**Leave messages enabled**",
                    value=str(joinleave_settings.leave_message_enabled)
                    if joinleave_settings.leave_message_enabled is not None
                    else "Not set (disabled)",
                ),
                EmbedField(
                    name="**Join message**",
                    value=joinleave_settings.join_message
                    if joinleave_settings.join_message is not None
                    else "Not set",
                ),
                EmbedField(
                    name="**Leave message**",
                    value=joinleave_settings.leave_message
                    if joinleave_settings.leave_message is not None
                    else "Not set",
                ),
            ],
        )

        await ctx.send(embed=embed)

    @slash_command(
        name="adm",
        group_name="set",
        group_description="Set settings for this guild",
        sub_cmd_name="admin-channel",
        sub_cmd_description="Set the admin channel",
        dm_permission=False,
        default_member_permissions=Permissions.MANAGE_GUILD,
    )
    @slash_option(
        name="channel",
        description="Channel to set as admin channel",
        required=True,
        opt_type=OptionTypes.CHANNEL,
        channel_types=[ChannelTypes.GUILD_TEXT],
    )
    async def adm_set_admin_channel(
        self, ctx: InteractionContext, channel: GuildChannel
    ) -> None:
        guild_settings: Optional[GuildSettingsModel]
        guild_settings, _ = GuildSettingsModel.get_or_create(guild_id=ctx.guild_id)
        guild_settings.admin_channel = channel.id
        guild_settings.save()
        await ctx.send(
            "Admin channel set to {}".format(channel.mention), ephemeral=True
        )


    @slash_command(
        name="adm",
        group_name="set",
        group_description="Set settings for this guild",
        sub_cmd_name="use-name-filter",
        sub_cmd_description="Set whether or not to use the name filter",
        dm_permission=False,
        default_member_permissions=Permissions.MANAGE_GUILD,
    )
    @slash_option(
        name="enabled",
        description="Whether or not to use the name filter",
        required=True,
        opt_type=OptionTypes.BOOLEAN,
    )
    async def adm_set_use_name_filter(self, ctx: InteractionContext, enabled: bool) -> None:
        guild_settings: Optional[GuildSettingsModel]
        guild_settings, _ = GuildSettingsModel.get_or_create(guild_id=ctx.guild_id)
        guild_settings.use_name_filter = enabled
        guild_settings.save()
        await ctx.send("Name filter set to {}".format(enabled), ephemeral=True)


    @slash_command(
        name="adm",
        group_name="set",
        group_description="Set settings for this guild",
        sub_cmd_name="use-gatekeep",
        sub_cmd_description="Set whether or not to use gatekeep",
        dm_permission=False,
        default_member_permissions=Permissions.MANAGE_GUILD,
    )
    @slash_option(
        name="enabled",
        description="Whether or not to use gatekeep",
        required=True,
        opt_type=OptionTypes.BOOLEAN,
    )
    async def adm_set_use_gatekeep(self, ctx: InteractionContext, enabled: bool) -> None:
        guild_settings: Optional[GuildSettingsModel]
        guild_settings, _ = GuildSettingsModel.get_or_create(guild_id=ctx.guild_id)
        guild_settings.use_gatekeep = enabled
        guild_settings.save()
        await ctx.send("Gatekeep set to {}".format(enabled), ephemeral=True)


    @slash_command(
        name="adm",
        group_name="set",
        group_description="Set settings for this guild",
        sub_cmd_name="join-leave-channel",
        sub_cmd_description="Set the join/leave messages channel",
        dm_permission=False,
        default_member_permissions=Permissions.MANAGE_GUILD,
    )
    @slash_option(
        name="channel",
        description="Channel to set as join/leave messages channel",
        required=True,
        opt_type=OptionTypes.CHANNEL,
        channel_types=[ChannelTypes.GUILD_TEXT],
    )
    async def adm_set_join_leave_channel(
        self, ctx: InteractionContext, channel: GuildChannel
    ) -> None:
        joinleave_settings: Optional[JoinLeaveModel]
        joinleave_settings, _ = JoinLeaveModel.get_or_create(guild_id=ctx.guild_id)
        joinleave_settings.message_channel = channel.id
        joinleave_settings.save()
        await ctx.send(
            "Join/leave messages channel set to {}".format(channel.mention), ephemeral=True
        )


    @slash_command(
        name="adm",
        group_name="set",
        group_description="Set settings for this guild",
        sub_cmd_name="join-message",
        sub_cmd_description="Set the join message and toggle its enabled state",
        dm_permission=False,
        default_member_permissions=Permissions.MANAGE_GUILD,
    )
    @slash_option(
        name="enabled",
        description="Whether or not to enable the join message",
        required=True,
        opt_type=OptionTypes.BOOLEAN,
    )
    @slash_option(
        name="message",
        description="The join message",
        required=False,
        opt_type=OptionTypes.STRING,
    )
    async def adm_set_join_message(
        self, ctx: InteractionContext, enabled: bool, message: str = None
    ) -> None:
        joinleave_settings: Optional[JoinLeaveModel]
        joinleave_settings, _ = JoinLeaveModel.get_or_create(guild_id=ctx.guild_id)
        joinleave_settings.join_message_enabled = enabled
        joinleave_settings.join_message = message
        joinleave_settings.save()
        if enabled:
            await ctx.send(
                "Join message enabled and set to {}".format(message), ephemeral=True
            )
        else:
            await ctx.send("Join message disabled", ephemeral=True)


    @slash_command(
        name="adm",
        group_name="set",
        group_description="Set settings for this guild",
        sub_cmd_name="leave-message",
        sub_cmd_description="Set the leave message and toggle its enabled state",
        dm_permission=False,
        default_member_permissions=Permissions.MANAGE_GUILD,
    )
    @slash_option(
        name="enabled",
        description="Whether or not to enable the leave message",
        required=True,
        opt_type=OptionTypes.BOOLEAN,
    )
    @slash_option(
        name="message",
        description="The leave message",
        required=False,
        opt_type=OptionTypes.STRING,
    )
    async def adm_set_leave_message(
        self, ctx: InteractionContext, enabled: bool, message: str = None
    ) -> None:
        joinleave_settings: Optional[JoinLeaveModel]
        joinleave_settings, _ = JoinLeaveModel.get_or_create(guild_id=ctx.guild_id)
        joinleave_settings.leave_message_enabled = enabled
        joinleave_settings.leave_message = message
        joinleave_settings.save()
        if enabled:
            await ctx.send(
                "Leave message enabled and set to {}".format(message), ephemeral=True
            )
        else:
            await ctx.send("Leave message disabled", ephemeral=True)


def setup(client: Client) -> None:
    Admin(client)
    logging.info("Admin extension loaded")