feat(aurora): allow for querying moderation history by date (before/after)

aurora/aurora.py

@@ -13,6 +13,7 @@ from datetime import datetime, timedelta, timezone
 from math import ceil
 
 import discord
+from dateparser import parse
 from discord.ext import tasks
 from redbot.core import app_commands, commands, data_manager
 from redbot.core.app_commands import Choice
@@ -520,6 +521,8 @@ class Aurora(commands.Cog):
         moderator: discord.User | None = None,
         pagesize: app_commands.Range[int, 1, 20] | None = None,
         page: int = 1,
+        before: str | None = None,
+        after: str | None = None,
         ephemeral: bool | None = None,
         inline: bool | None = None,
         export: bool = False,
@@ -536,6 +539,10 @@ class Aurora(commands.Cog):
             Amount of infractions to list per page
         page: int
             Page to select
+        before: str
+            List infractions before a certain date
+        after: str
+            List infractions after a certain date
         ephemeral: bool
             Hide the command response
         inline: bool
@@ -570,6 +577,22 @@ class Aurora(commands.Cog):
                     or 5
                 )
 
+        if before:
+            before = parse(before)
+            if before is None:
+                return await interaction.response.send_message(
+                    content=error("Invalid date format for `before`."), ephemeral=True
+                )
+            before = before.replace(tzinfo=timezone.utc)
+
+        if after:
+            after = parse(after)
+            if after is None:
+                return await interaction.response.send_message(
+                    content=error("Invalid date format for `after`."), ephemeral=True
+                )
+            after = after.replace(tzinfo=timezone.utc)
+
         await interaction.response.defer(ephemeral=ephemeral)
 
         permissions = check_permissions(
@@ -586,13 +609,13 @@ class Aurora(commands.Cog):
 
         if target:
             filename = f"moderation_target_{str(target.id)}_{str(interaction.guild.id)}.json"
-            moderations = await Moderation.find_by_target(interaction.client, interaction.guild.id, target.id)
+            moderations = await Moderation.find_by_target(bot=interaction.client, guild_id=interaction.guild.id, target=target.id, before=before, after=after)
         elif moderator:
             filename = f"moderation_moderator_{str(moderator.id)}_{str(interaction.guild.id)}.json"
-            moderations = await Moderation.find_by_moderator(interaction.client, interaction.guild.id, moderator.id)
+            moderations = await Moderation.find_by_moderator(bot=interaction.client, guild_id=interaction.guild.id, moderator=moderator.id, before=before, after=after)
         else:
             filename = f"moderation_{str(interaction.guild.id)}.json"
-            moderations = await Moderation.get_latest(interaction.client, interaction.guild.id)
+            moderations = await Moderation.get_latest(bot=interaction.client, guild_id=interaction.guild.id, before=before, after=after)
 
         if export:
             try:

aurora/info.json

@@ -9,7 +9,7 @@
   "disabled": false,
   "min_bot_version": "3.5.0",
   "min_python_version": [3, 10, 0],
-  "requirements": ["pydantic", "aiosqlite", "phx-class-registry"],
+  "requirements": ["pydantic", "aiosqlite", "phx-class-registry", "dateparser"],
   "tags": [
       "mod",
       "moderate",

aurora/models/moderation.py

@@ -307,13 +307,19 @@ class Moderation(AuroraGuildModel):
         return results
 
     @classmethod
-    async def get_latest(cls, bot: Red, guild_id: int, limit: int | None = None, offset: int = 0, types: Iterable[Type] | None = None, cursor: Cursor | None = None) -> Tuple["Moderation"]:
+    async def get_latest(cls, bot: Red, guild_id: int, before: datetime = None, after: datetime = None, limit: int | None = None, offset: int = 0, types: Iterable[Type] | None = None, cursor: Cursor | None = None) -> Tuple["Moderation"]:
         params = []
         query = f"SELECT * FROM moderation_{guild_id} ORDER BY moderation_id DESC"
         if types:
             query += f" WHERE moderation_type IN ({', '.join(['?' for _ in types])})"
             for t in types:
                 params.append(t.key)
+        if before:
+            query += " WHERE timestamp < ?"
+            params.append(before.timestamp())
+        if after:
+            query += " WHERE timestamp > ?"
+            params.append(after.timestamp())
         if limit:
             query += " LIMIT ? OFFSET ?"
             params.extend((limit, offset))
@@ -334,22 +340,40 @@ class Moderation(AuroraGuildModel):
         raise ValueError(f"Case {moderation_id} not found in moderation_{guild_id}!")
 
     @classmethod
-    async def find_by_target(cls, bot: Red, guild_id: int, target: int, types: Iterable[Type] | None = None, cursor: Cursor | None = None) -> Tuple["Moderation"]:
+    async def find_by_target(cls, bot: Red, guild_id: int, target: int, before: datetime = None, after: datetime = None, types: Iterable[Type] | None = None, cursor: Cursor | None = None) -> Tuple["Moderation"]:
         query = f"SELECT * FROM moderation_{guild_id} WHERE target_id = ?"
+        params = [target]
         if types:
             query += f" AND moderation_type IN ({', '.join(['?' for _ in types])})"
+            for t in types:
+                params.append(t.key)
+        if before:
+            query += " AND timestamp < ?"
+            params.append(before.timestamp())
+        if after:
+            query += " AND timestamp > ?"
+            params.append(after.timestamp())
         query += " ORDER BY moderation_id DESC;"
 
-        return await cls.execute(bot=bot, guild_id=guild_id, query=query, parameters=(target, *[t.key for t in types]) if types else (target,), cursor=cursor)
+        return await cls.execute(bot=bot, guild_id=guild_id, query=query, parameters=params, cursor=cursor)
 
     @classmethod
-    async def find_by_moderator(cls, bot: Red, guild_id: int, moderator: int, types: Iterable[Type] | None = None, cursor: Cursor | None = None) -> Tuple["Moderation"]:
+    async def find_by_moderator(cls, bot: Red, guild_id: int, moderator: int, before: datetime = None, after: datetime = None, types: Iterable[Type] | None = None, cursor: Cursor | None = None) -> Tuple["Moderation"]:
         query = f"SELECT * FROM moderation_{guild_id} WHERE moderator_id = ?"
+        params = [moderator]
         if types:
             query += f" AND moderation_type IN ({', '.join(['?' for _ in types])})"
+            for t in types:
+                params.append(t.key)
+        if before:
+            query += " AND timestamp < ?"
+            params.append(before.timestamp())
+        if after:
+            query += " AND timestamp > ?"
+            params.append(after.timestamp())
         query += " ORDER BY moderation_id DESC;"
 
-        return await cls.execute(bot=bot, guild_id=guild_id, query=query, parameters=(moderator, *[t.key for t in types]) if types else (moderator,), cursor=cursor)
+        return await cls.execute(bot=bot, guild_id=guild_id, query=query, parameters=params, cursor=cursor)
 
     @classmethod
     async def log(