Create and delete persistent notes

Author: RealCyGuy

cogs/modmail.py

@@ -901,7 +901,7 @@ async def note_persistent(self, ctx, *, msg: str = ""):
         async with ctx.typing():
             msg = await ctx.thread.note(ctx.message, persistent=True)
             await msg.pin()
-        await self.bot.api.create_note(recipient=ctx.thread.recipient, message=ctx.message)
+        await self.bot.api.create_note(recipient=ctx.thread.recipient, message=ctx.message, message_id=msg.id)
 
     @commands.command()
     @checks.has_permissions(PermissionLevel.SUPPORTER)

core/clients.py

@@ -142,6 +142,21 @@ async def search_closed_by(self, user_id: Union[int, str]):
     async def search_by_text(self, text: str, limit: Optional[int]):
         return NotImplemented
 
+    async def create_note(self, recipient: Member, message: Message, message_id: Union[int, str]):
+        return NotImplemented
+
+    async def find_notes(self, recipient: Member):
+        return NotImplemented
+
+    async def update_note_ids(self, ids: dict):
+        return NotImplemented
+
+    async def delete_note(self, message_id: Union[int, str]):
+        return NotImplemented
+
+    async def edit_note(self, message_id: Union[int, str]):
+        return NotImplemented
+
     def get_plugin_partition(self, cog):
         return NotImplemented
 
@@ -401,25 +416,34 @@ async def search_by_text(self, text: str, limit: Optional[int]):
             {"messages": {"$slice": 5}},
         ).to_list(limit)
 
-    async def create_note(self, recipient: Member, message: Message):
+    async def create_note(self, recipient: Member, message: Message, message_id: Union[int, str]):
         await self.db.notes.insert_one(
             {
                 "recipient": str(recipient.id),
                 "author": {
                     "id": str(message.author.id),
                     "name": message.author.name,
                     "discriminator": message.author.discriminator,
-                    "avatar_url": str(message.author.avatar_url),
+                    "avatar_url": str(message.author.avatar_url)
                 },
+                "message": message.content,
+                "message_id": str(message_id),
             }
         )
 
-    async def delete_note(self):
-        pass
-
     async def find_notes(self, recipient: Member):
         return await self.db.notes.find({"recipient": str(recipient.id)}).to_list(None)
 
+    async def update_note_ids(self, ids: dict):
+        for object_id, message_id in ids.items():
+            await self.db.notes.update_one({"_id": object_id}, {"$set": {"message_id": message_id}})
+
+    async def delete_note(self, message_id: Union[int, str]):
+        await self.db.notes.delete_one({"message_id": str(message_id)})
+
+    async def edit_note(self, message_id: Union[int, str]):
+        return NotImplemented
+
     def get_plugin_partition(self, cog):
         cls_name = cog.__class__.__name__
         return self.db.plugins[cls_name]

core/thread.py

@@ -3,6 +3,7 @@
 import re
 import typing
 from datetime import datetime, timedelta
+import time
 from types import SimpleNamespace
 
 import isodate
@@ -191,13 +192,42 @@ async def send_recipient_genesis_message():
                     await self.bot.add_reaction(msg, close_emoji)
 
         async def send_persistent_notes():
-            notes = await self.bot.api.find_notes()
+            notes = await self.bot.api.find_notes(self.recipient)
+            ids = {}
+
+            class State:
+                def store_user(self, user):
+                    return user
+
             for note in notes:
-                message = discord.Message()
-                await self.note(note.message)
-                pass
+                author = note["author"]
+
+                class Author:
+                    name = author["name"]
+                    id = author["id"]
+                    discriminator = author["discriminator"]
+                    avatar_url = author["avatar_url"]
+
+                data = {
+                    "id": round(time.time() * 1000 - discord.utils.DISCORD_EPOCH) << 22,
+                    "attachments": {},
+                    "embeds": {},
+                    "edited_timestamp": None,
+                    "type": None,
+                    "pinned": None,
+                    "mention_everyone": None,
+                    "tts": None,
+                    "content": note["message"],
+                    "author": Author(),
+                }
+                message = discord.Message(state=State(), channel=None, data=data)
+                ids[note["_id"]] = str((await self.note(message, persistent=True, thread_creation=True)).id)
+
+            await self.bot.api.update_note_ids(ids)
 
-        await asyncio.gather(send_genesis_message(), send_recipient_genesis_message())
+        await asyncio.gather(
+            send_genesis_message(), send_recipient_genesis_message(), send_persistent_notes()
+        )
         self.bot.dispatch("thread_ready", self)
 
     def _format_info_embed(self, user, log_url, log_count, color):
@@ -517,11 +547,14 @@ async def find_linked_messages(
             ):
                 raise ValueError("Thread message not found.")
 
-            if message1.embeds[0].color.value == self.bot.main_color and message1.embeds[
-                0
-            ].author.name.startswith("Note"):
+            if message1.embeds[0].color.value == self.bot.main_color and (
+                message1.embeds[0].author.name.startswith("Note")
+                or message1.embeds[0].author.name.startswith("Persistent Note")
+            ):
                 if not note:
                     raise ValueError("Thread message not found.")
+                elif message1.embeds[0].author.name.startswith("Persistent Note"):
+                    await self.bot.api.delete_note(message_id)
                 return message1, None
 
             if message1.embeds[0].color.value != self.bot.mod_color and not (
@@ -636,11 +669,11 @@ async def edit_dm_message(self, message: discord.Message, content: str) -> None:
             self.bot.api.edit_message(message.id, content), linked_message.edit(embed=embed)
         )
 
-    async def note(self, message: discord.Message, persistent=False) -> None:
+    async def note(self, message: discord.Message, persistent=False, thread_creation=False) -> None:
         if not message.content and not message.attachments:
             raise MissingRequiredArgument(SimpleNamespace(name="msg"))
 
-        msg = await self.send(message, self.channel, note=True, persistent_note=persistent)
+        msg = await self.send(message, self.channel, note=True, persistent_note=persistent, thread_creation=thread_creation)
 
         self.bot.loop.create_task(
             self.bot.api.append_log(
@@ -727,6 +760,7 @@ async def send(
         anonymous: bool = False,
         plain: bool = False,
         persistent_note: bool = False,
+        thread_creation: bool = False,
     ) -> None:
 
         self.bot.loop.create_task(
@@ -876,7 +910,7 @@ async def send(
             embed.set_footer(text=f"Message ID: {message.id}")
             embed.colour = self.bot.recipient_color
 
-        if from_mod or note:
+        if (from_mod or note) and not thread_creation:
             delete_message = not bool(message.attachments)
             if delete_message and destination == self.channel:
                 try: