fix: unsnooze bug

Author: lorenzo132

cogs/modmail.py

@@ -2285,7 +2285,9 @@ async def snooze(self, ctx, *, after: UserFriendlyTime = None):
                 snooze_for = max_snooze
         else:
             snooze_for = max_snooze
-        now = datetime.utcnow()
+
+        # Storing snooze_start and snooze_for in the log entry
+        now = datetime.now(timezone.utc)
         await self.bot.api.logs.update_one(
             {"recipient.id": str(thread.id)},
             {"$set": {"snooze_start": now.isoformat(), "snooze_for": snooze_for}},
@@ -2296,7 +2298,7 @@ async def snooze(self, ctx, *, after: UserFriendlyTime = None):
             color=self.bot.error_color,
         )
         await ctx.send(embed=embed)
-        ok = await thread.snooze(moderator=ctx.author)
+        ok = await thread.snooze(moderator=ctx.author, snooze_for=snooze_for)
         if ok:
             logging.info(
                 f"[SNOOZE] Thread for {getattr(thread.recipient, 'id', None)} snoozed for {snooze_for}s."
@@ -2341,6 +2343,13 @@ async def unsnooze(self, ctx, *, user: str = None):
             await ctx.send("This thread is not snoozed.")
             logging.info(f"[UNSNOOZE] Thread for {getattr(thread.recipient, 'id', None)} is not snoozed.")
             return
+
+        # Manually fetch snooze_data if the thread object doesn't have it
+        if not thread.snooze_data:
+            log_entry = await self.bot.api.logs.find_one({"recipient.id": str(thread.id), "snoozed": True})
+            if log_entry:
+                thread.snooze_data = log_entry.get("snooze_data")
+
         ok = await thread.restore_from_snooze()
         if ok:
             self.bot.threads.cache[thread.id] = thread
@@ -2360,37 +2369,44 @@ async def snoozed(self, ctx):
         """
         List all currently snoozed threads/users.
         """
-        snoozed = await self.bot.api.logs.find({"snoozed": True}).to_list(None)
-        if not snoozed:
+        snoozed_threads = [thread for thread in self.bot.threads.cache.values() if thread.snoozed]
+        if not snoozed_threads:
             await ctx.send("No threads are currently snoozed.")
             return
+
         lines = []
-        now = datetime.utcnow()
-        for entry in snoozed:
-            user = entry.get("recipient", {}).get("name", "Unknown")
-            user_id = entry.get("recipient", {}).get("id", "?")
-            since = entry.get("snooze_start")
-            duration = entry.get("snooze_for")
-            if since:
-                try:
-                    since_dt = datetime.fromisoformat(since)
-                    since_str = f"<t:{int(since_dt.timestamp())}:R>"  # Discord relative timestamp
-                except Exception as e:
-                    since_str = "?"
-                    logging.warning(f"[SNOOZED] Invalid snooze_start for {user_id}: {since} ({e})")
-            else:
-                since_str = "?"
-                logging.warning(f"[SNOOZED] Missing snooze_start for {user_id}")
-            if duration and since_str != "?":
-                try:
-                    until_dt = datetime.fromisoformat(since) + timedelta(seconds=int(duration))
-                    until_str = f"<t:{int(until_dt.timestamp())}:R>"
-                except Exception as e:
-                    until_str = "?"
-                    logging.warning(f"[SNOOZED] Invalid until time for {user_id}: {since} + {duration} ({e})")
-            else:
-                until_str = "?"
+        now = datetime.now(timezone.utc)
+        for thread in snoozed_threads:
+            user = thread.recipient.name if thread.recipient else "Unknown"
+            user_id = thread.id
+
+            since_str = "?"
+            until_str = "?"
+
+            if thread.snooze_data:
+                since = thread.snooze_data.get("snooze_start")
+                duration = thread.snooze_data.get("snooze_for")
+
+                if since:
+                    try:
+                        since_dt = datetime.fromisoformat(since)
+                        since_str = f"<t:{int(since_dt.timestamp())}:R>"  # Discord relative timestamp
+                    except (ValueError, TypeError) as e:
+                        logging.warning(f"[SNOOZED] Invalid snooze_start for {user_id}: {since} ({e})")
+                else:
+                    logging.warning(f"[SNOOZED] Missing snooze_start for {user_id}")
+
+                if duration and since_str != "?":
+                    try:
+                        until_dt = datetime.fromisoformat(since) + timedelta(seconds=int(duration))
+                        until_str = f"<t:{int(until_dt.timestamp())}:R>"
+                    except (ValueError, TypeError) as e:
+                        logging.warning(
+                            f"[SNOOZED] Invalid until time for {user_id}: {since} + {duration} ({e})"
+                        )
+
             lines.append(f"- {user} (`{user_id}`) since {since_str}, until {until_str}")
+
         await ctx.send("Snoozed threads:\n" + "\n".join(lines))
 
     async def cog_load(self):

core/thread.py

@@ -8,7 +8,7 @@
 import traceback
 import typing
 import warnings
-from datetime import timedelta
+from datetime import timedelta, datetime, timezone
 from types import SimpleNamespace
 
 import isodate
@@ -130,7 +130,7 @@ def cancelled(self, flag: bool):
             for i in self.wait_tasks:
                 i.cancel()
 
-    async def snooze(self, moderator=None, command_used=None):
+    async def snooze(self, moderator=None, command_used=None, snooze_for=None):
         """
         Save channel/category/position/messages to DB, mark as snoozed, delete channel.
         """
@@ -151,6 +151,7 @@ async def snooze(self, moderator=None, command_used=None):
                 if log_entry and "key" in log_entry:
                     self.log_key = log_entry["key"]
 
+        now = datetime.now(timezone.utc)
         self.snooze_data = {
             "category_id": channel.category_id,
             "position": channel.position,
@@ -166,7 +167,6 @@ async def snooze(self, moderator=None, command_used=None):
                     "attachments": [a.url for a in m.attachments],
                     "embeds": [e.to_dict() for e in m.embeds],
                     "created_at": m.created_at.isoformat(),
-                    # Only use 'mod_only' if this is an internal note (note command), safe check for embed author
                     "type": (
                         "mod_only"
                         if (
@@ -182,7 +182,6 @@ async def snooze(self, moderator=None, command_used=None):
                     "author_name": getattr(m.author, "name", None),
                 }
                 async for m in channel.history(limit=None, oldest_first=True)
-                # Only include if not already internal/note, safe check for embed author
                 if not (
                     m.embeds
                     and getattr(m.embeds[0], "author", None)
@@ -195,7 +194,9 @@ async def snooze(self, moderator=None, command_used=None):
             ],
             "snoozed_by": getattr(moderator, "name", None) if moderator else None,
             "snooze_command": command_used,
-            "log_key": self.log_key,  # Preserve the log_key
+            "log_key": self.log_key,
+            "snooze_start": now.isoformat(),
+            "snooze_for": snooze_for,
         }
         self.snoozed = True
         # Save to DB (robust: try recipient.id, then channel_id)
@@ -289,19 +290,19 @@ async def restore_from_snooze(self):
         if self.log_key:
             result = await self.bot.api.logs.update_one(
                 {"key": self.log_key},
-                {"$set": {"snoozed": False, "channel_id": str(channel.id)}, "$unset": {"snooze_data": ""}},
+                {"$set": {"channel_id": str(channel.id)}, "$unset": {"snoozed": "", "snooze_data": ""}},
             )
         else:
             result = await self.bot.api.logs.update_one(
                 {"recipient.id": str(self.id)},
-                {"$set": {"snoozed": False, "channel_id": str(channel.id)}, "$unset": {"snooze_data": ""}},
+                {"$set": {"channel_id": str(channel.id)}, "$unset": {"snoozed": "", "snooze_data": ""}},
             )
             if result.modified_count == 0:
                 result = await self.bot.api.logs.update_one(
                     {"channel_id": str(channel.id)},
                     {
-                        "$set": {"snoozed": False, "channel_id": str(channel.id)},
-                        "$unset": {"snooze_data": ""},
+                        "$set": {"channel_id": str(channel.id)},
+                        "$unset": {"snoozed": "", "snooze_data": ""},
                     },
                 )
         import logging