feat(aurora): renamed moderation cog to aurora, converted to sqlite3

aurora/utilities/utils.py

@@ -0,0 +1,234 @@
+# pylint: disable=cyclic-import
+
+import json
+from typing import Union
+
+from discord import Guild, Interaction, Member, User
+from discord.errors import Forbidden, NotFound
+from redbot.core import commands
+
+from .config import config
+
+
+async def check_conf(config_list: list):
+    """Checks if any required config options are not set."""
+    not_found_list = []
+
+    for item in config_list:
+        if await config.item() == " ":
+            not_found_list.append(item)
+
+    return not_found_list
+
+
+def check_permissions(
+    user: User,
+    permissions: list,
+    ctx: Union[commands.Context, Interaction] = None,
+    guild: Guild = None,
+):
+    """Checks if a user has a specific permission (or a list of permissions) in a channel."""
+    if ctx:
+        member = ctx.guild.get_member(user.id)
+        resolved_permissions = ctx.channel.permissions_for(member)
+
+    elif guild:
+        member = guild.get_member(user.id)
+        resolved_permissions = member.guild_permissions
+
+    else:
+        raise (KeyError)
+
+    for permission in permissions:
+        if (
+            not getattr(resolved_permissions, permission, False)
+            and not resolved_permissions.administrator is True
+        ):
+            return permission
+
+    return False
+
+
+async def check_moddable(
+    target: Union[User, Member], interaction: Interaction, permissions: list
+):
+    """Checks if a moderator can moderate a target."""
+    if check_permissions(interaction.client.user, permissions, guild=interaction.guild):
+        await interaction.response.send_message(
+            f"I do not have the `{permissions}` permission, required for this action.",
+            ephemeral=True,
+        )
+        return False
+
+    if await config.guild(interaction.guild).use_discord_permissions() is True:
+        if check_permissions(interaction.user, permissions, guild=interaction.guild):
+            await interaction.response.send_message(
+                f"You do not have the `{permissions}` permission, required for this action.",
+                ephemeral=True,
+            )
+            return False
+
+    if interaction.user.id == target.id:
+        await interaction.response.send_message(
+            content="You cannot moderate yourself!", ephemeral=True
+        )
+        return False
+
+    if target.bot:
+        await interaction.response.send_message(
+            content="You cannot moderate bots!", ephemeral=True
+        )
+        return False
+
+    if isinstance(target, Member):
+        if interaction.user.top_role <= target.top_role:
+            await interaction.response.send_message(
+                content="You cannot moderate members with a higher role than you!",
+                ephemeral=True,
+            )
+            return False
+
+        if (
+            interaction.guild.get_member(interaction.client.user.id).top_role
+            <= target.top_role
+        ):
+            await interaction.response.send_message(
+                content="You cannot moderate members with a role higher than the bot!",
+                ephemeral=True,
+            )
+            return False
+
+        immune_roles = await config.guild(target.guild).immune_roles()
+
+        for role in target.roles:
+            if role.id in immune_roles:
+                await interaction.response.send_message(
+                    content="You cannot moderate members with an immune role!",
+                    ephemeral=True,
+                )
+                return False
+
+    return True
+
+
+async def get_next_case_number(guild_id: str, cursor=None):
+    """This function returns the next case number from the MySQL table for a specific guild."""
+    from .database import connect
+
+    if not cursor:
+        database = connect()
+        cursor = database.cursor()
+    cursor.execute(
+        f"SELECT moderation_id FROM `moderation_{guild_id}` ORDER BY moderation_id DESC LIMIT 1"
+    )
+    return cursor.fetchone()[0] + 1
+
+
+def generate_dict(result):
+    case: dict = {
+        "moderation_id": result[0],
+        "timestamp": result[1],
+        "moderation_type": result[2],
+        "target_type": result[3],
+        "target_id": result[4],
+        "moderator_id": result[5],
+        "role_id": result[6],
+        "duration": result[7],
+        "end_timestamp": result[8],
+        "reason": result[9],
+        "resolved": result[10],
+        "resolved_by": result[11],
+        "resolve_reason": result[12],
+        "expired": result[13],
+        "changes": json.loads(result[14]),
+        "metadata": json.loads(result[15])
+    }
+    return case
+
+
+async def fetch_user_dict(interaction: Interaction, user_id: str):
+    """This function returns a dictionary containing either user information or a standard deleted user template."""
+    if user_id == "?":
+        user_dict = {"id": "?", "name": "Unknown User", "discriminator": "0"}
+
+    else:
+        try:
+            user = interaction.client.get_user(user_id)
+            if user is None:
+                user = await interaction.client.fetch_user(user_id)
+
+            user_dict = {
+                "id": user.id,
+                "name": user.name,
+                "discriminator": user.discriminator,
+            }
+
+        except NotFound:
+            user_dict = {
+                "id": user_id,
+                "name": "Deleted User",
+                "discriminator": "0",
+            }
+
+    return user_dict
+
+
+async def fetch_channel_dict(interaction: Interaction, channel_id: str):
+    """This function returns a dictionary containing either channel information or a standard deleted channel template."""
+    try:
+        channel = interaction.guild.get_channel(channel_id)
+        if not channel:
+            channel = await interaction.guild.fetch_channel(channel_id)
+
+        channel_dict = {"id": channel.id, "name": channel.name, "mention": channel.mention}
+
+    except NotFound:
+        channel_dict = {"id": channel_id, "name": "Deleted Channel", "mention": None}
+
+    return channel_dict
+
+
+async def fetch_role_dict(interaction: Interaction, role_id: str):
+    """This function returns a dictionary containing either role information or a standard deleted role template."""
+    role = interaction.guild.get_role(role_id)
+    if not role:
+        role_dict = {"id": role_id, "name": "Deleted Role"}
+
+    role_dict = {"id": role.id, "name": role.name}
+
+    return role_dict
+
+
+async def log(interaction: Interaction, moderation_id: int, resolved: bool = False):
+    """This function sends a message to the guild's configured logging channel when an infraction takes place."""
+    from .database import fetch_case
+    from .embed_factory import embed_factory
+
+    logging_channel_id = await config.guild(interaction.guild).log_channel()
+    if logging_channel_id != " ":
+        logging_channel = interaction.guild.get_channel(logging_channel_id)
+
+        case = await fetch_case(moderation_id, interaction.guild.id)
+        if case:
+            embed = await embed_factory(
+                "log", await interaction.client.get_embed_color(None), interaction=interaction, case_dict=case, resolved=resolved
+            )
+            try:
+                await logging_channel.send(embed=embed)
+            except Forbidden:
+                return
+
+async def send_evidenceformat(interaction: Interaction, case_dict: dict):
+    """This function sends an ephemeral message to the moderator who took the moderation action, with a pre-made codeblock for use in the mod-evidence channel."""
+    from .embed_factory import embed_factory
+
+    send_evidence_bool = (await config.user(interaction.user).auto_evidenceformat()
+        or await config.guild(interaction.guild).auto_evidenceformat()
+        or False)
+    if send_evidence_bool is False:
+        return
+
+    content = await embed_factory(
+        "evidenceformat", await interaction.client.get_embed_color(None), interaction=interaction, case_dict=case_dict
+    )
+    await interaction.followup.send(content=content, ephemeral=True)