Add support for pin bridging

Author: greeeen-dev

requirements.txt

@@ -1,4 +1,4 @@
-py-cord
+py-cord[speed]
 python-dotenv
 pycryptodome
 ujson
@@ -9,7 +9,7 @@ jellyfish
 tld
 better-profanity
 stoat.py
-aiohttp
+aiohttp[speedups]
 argon2-cffi
 psutil
 git+https://github.com/greeeen-dev/capacitor.git

shinobu/beacon/cogs/frontend.py

@@ -19,10 +19,12 @@
 import uuid
 import discord
 from discord.ext import commands, bridge
-from shinobu.runtime.models import shinobu_cog
+from shinobu.runtime.models import shinobu_cog, ui_kit
 from shinobu.beacon.protocol import beacon
 from shinobu.beacon.models import (space as beacon_space, driver as beacon_driver, server as beacon_server,
                                    channel as beacon_channel, webhook as beacon_webhook)
+from shinobu.runtime.models.ui_kit import ShinobuListEntry
+
 
 class BeaconFrontend(shinobu_cog.ShinobuCog):
     def __init__(self, bot):
@@ -71,6 +73,43 @@ async def delete_space(self, ctx: bridge.BridgeApplicationContext | bridge.Bridg
         await ctx.respond(f"space deleted T.T")
         await self.bot.loop.run_in_executor(None, self._beacon.save_data)
 
+    @bridge_universal.command(name="spaces")
+    async def list_spaces(self, ctx: bridge.BridgeApplicationContext | bridge.BridgeExtContext, space_id: str | None = None):
+        """Shows all available Spaces."""
+
+        # Get driver
+        discord_driver: beacon_driver.BeaconDriver = self._beacon.drivers.get_driver("discord")
+
+        # Create new list UI
+        list_ui: ui_kit.ShinobuListDiscordView = ui_kit.ShinobuListDiscordView(
+            "Available Spaces",
+            "Available Spaces",
+            self.bot.colors.shinobu
+        )
+
+        # Add spaces
+        for space in self._beacon.spaces.all_spaces:
+            should_hide: bool = False
+            if space.private:
+                # Check if we have access to this space
+                should_hide = not space.has_access(discord_driver.get_server(str(ctx.guild.id)))
+
+            entry: ShinobuListEntry = ShinobuListEntry(
+                entry_id=space.id,
+                name=space.name,
+                emoji=space.emoji,
+                hidden=should_hide
+            )
+            entry.add_field(
+                name="Space ID",
+                value=f"`{space.id}`"
+            )
+
+            list_ui.add_entry(entry)
+
+        # Run loop
+        await list_ui.run(self.bot, ctx)
+
     @bridge_universal.command(name="join-space")
     @commands.is_owner()
     async def join_space(self, ctx: bridge.BridgeApplicationContext | bridge.BridgeExtContext, space_id: str):

shinobu/beacon/discord/driver.py

@@ -312,6 +312,8 @@ async def _to_discord_content(self, content: beacon_message.BeaconMessageContent
 
         # Process reply
         has_reply: bool = False
+        is_pin: bool = content.type == beacon_message.BeaconMessageType.pins_add
+
         for reply_message_group in content.replies:
             # Find channel-specific reply
             # noinspection DuplicatedCode
@@ -335,7 +337,7 @@ async def _to_discord_content(self, content: beacon_message.BeaconMessageContent
             # noinspection PyTypeChecker
             reply_button: discord.ui.Button = discord.ui.Button(
                 style=discord.ButtonStyle.link,
-                label=f'Jump to message',
+                label=f'Jump',
                 url=reply_url
             )
 
@@ -357,6 +359,11 @@ async def _to_discord_content(self, content: beacon_message.BeaconMessageContent
                     f"\U000021AA\U0000FE0F **Replying to @{reply_author}** \U0001F5BC\U0000FE0F"
                 )
 
+            if is_pin:
+                reply_text = discord.ui.TextDisplay(
+                    f"\U0001F4CC *Pinned a message from @{reply_author}.*"
+                )
+
             # Create reply action row
             reply_section: discord.ui.Section = discord.ui.Section(
                 reply_text, accessory=reply_button
@@ -376,12 +383,15 @@ async def _to_discord_content(self, content: beacon_message.BeaconMessageContent
             if reply_content_trimmed:
                 reply_button_text = f'Replying to @{reply_author} | {reply_content_trimmed}'
 
+            if is_pin:
+                reply_button_text = f"Pinned a message from @{reply_author}"
+
             # noinspection PyTypeChecker
             legacy_reply_components.add_item(discord.ui.ActionRow(
                 discord.ui.Button(
                     style=discord.ButtonStyle.link,
                     label=reply_button_text,
-                    emoji='\U000021AA\U0000FE0F',
+                    emoji="\U000021AA\U0000FE0F" if not is_pin else "\U0001F4CC",
                     url=reply_url
                 )
             ))
@@ -786,3 +796,17 @@ async def _purge(self, messages: list[beacon_message.BeaconMessage]):
 
         # Delete messages
         await channel.delete_messages([discord.Object(int(message.id)) for message in messages])
+
+    async def _pin(self, message: beacon_message.BeaconMessage):
+        channel = self.bot.get_channel(int(message.channel.id))
+        partial_message: discord.PartialMessage = discord.PartialMessage(channel=channel, id=int(message.id))
+
+        # Pin message
+        await partial_message.pin()
+
+    async def _unpin(self, message: beacon_message.BeaconMessage):
+        channel = self.bot.get_channel(int(message.channel.id))
+        partial_message: discord.PartialMessage = discord.PartialMessage(channel=channel, id=int(message.id))
+
+        # Unpin message
+        await partial_message.unpin()

shinobu/beacon/discord/parent.py

@@ -144,6 +144,9 @@ async def _to_beacon_content(self, message: discord.Message) -> beacon_message.B
         results = await asyncio.gather(*tasks, return_exceptions=True)
         files: list[beacon_file.BeaconFile] = [result for result in results if type(result) is beacon_file.BeaconFile]
 
+        # Get pin status
+        is_pin: bool = message.type == discord.MessageType.pins_add
+
         # Assemble blocks
         blocks: dict[str, beacon_content.BeaconContentBlock] = {
             "content": text_content
@@ -162,7 +165,8 @@ async def _to_beacon_content(self, message: discord.Message) -> beacon_message.B
             files=files,
             replies=replies,
             reply_content=self._driver.sanitize_outbound(reply_content) if reply_content else None,
-            reply_attachments=reply_attachments
+            reply_attachments=reply_attachments,
+            message_type=beacon_message.BeaconMessageType.pins_add if is_pin else None
         )
 
         return content
@@ -294,11 +298,53 @@ async def handle_delete(self, message: discord.Message):
         except beacon.BeaconPlatformDisabled:
             pass
 
+    async def handle_pin(self, message: discord.Message):
+        # noinspection DuplicatedCode
+        origin_driver: beacon_driver.BeaconDriver = self._beacon.drivers.get_driver("discord")
+
+        # Get the BeaconMessage object for the message
+        message_obj: beacon_message.BeaconMessage = self._beacon.messages.get_message(str(message.id))
+        if not message_obj:
+            # We can't pin messages that aren't cached
+            return
+
+        # Convert guild data to server.BeaconServer
+        server: beacon_server.BeaconServer = origin_driver.get_server(str(message.guild.id))
+
+        # Convert channel data to channel.BeaconChannel
+        # noinspection DuplicatedCode
+        channel: beacon_channel.BeaconChannel = origin_driver.get_channel(server, str(message.channel.id))
+        if not channel:
+            # We can't bridge
+            return
+
+        # Get Space
+        space: beacon_space.BeaconSpace = self._beacon.spaces.get_space_for_channel(channel)
+
+        if not space:
+            # We can't bridge pins, even if it was sent in the Space by the server
+            return
+
+        # Pin the message!
+        try:
+            await self._beacon.pin(message=message_obj, unpin=not message.pinned)
+        except beacon.BeaconPlatformDisabled:
+            pass
+
     @commands.Cog.listener()
     async def on_message(self, message: discord.Message):
         origin_driver: beacon_driver.BeaconDriver = self._beacon.drivers.get_driver("discord")
 
-        # noinspection DuplicatedCode
+        supported_types: list[discord.MessageType] = [
+            discord.MessageType.default,
+            discord.MessageType.reply,
+            discord.MessageType.pins_add
+        ]
+        supported_types_community: list[discord.MessageType] = [
+            discord.MessageType.default,
+            discord.MessageType.reply
+        ]
+
         if message.content.startswith(self.bot.command_prefix):
             # Assume this is a text command
             return
@@ -307,6 +353,11 @@ async def on_message(self, message: discord.Message):
             # Do not self-bridge
             return
 
+        if message.type not in supported_types:
+            # Unsupported message
+            return
+
+        # noinspection DuplicatedCode
         if message.webhook_id:
             # Check if the webhook was ours (to prevent a self-bridge)
             webhook: discord.Webhook | None = origin_driver.webhooks.get_webhook(str(message.webhook_id))
@@ -386,14 +437,38 @@ async def on_message(self, message: discord.Message):
             pass
 
     @commands.Cog.listener()
-    async def on_message_edit(self, _, message: discord.Message):
+    async def on_message_edit(self, before: discord.Message, message: discord.Message):
+        # Identify update type
+        is_pin: bool = before.pinned != message.pinned
+
         # Check if message is pending
         if self._beacon.is_pending(str(message.id)):
             # Add callback
-            self._beacon.add_callback(str(message.id), self.handle_edit, [message])
+            if is_pin:
+                self._beacon.add_callback(str(message.id), self.handle_pin, [message])
+            else:
+                self._beacon.add_callback(str(message.id), self.handle_edit, [message])
+        else:
+            # Run directly
+            if is_pin:
+                await self.handle_pin(message)
+            else:
+                await self.handle_edit(message)
+
+    @commands.Cog.listener()
+    async def on_raw_message_edit(self, payload: discord.RawMessageUpdateEvent):
+        # Do not handle cached messages (on_message_edit does this for us)
+        if payload.cached_message:
+            return
+
+        # For uncached messages, we can only handle content edits for now. This may change in a future update
+        # Check if message is pending
+        if self._beacon.is_pending(str(payload.new_message.id)):
+            # Add callback
+            self._beacon.add_callback(str(payload.new_message.id), self.handle_edit, [payload.new_message])
         else:
             # Run directly
-            await self.handle_edit(message)
+            await self.handle_edit(payload.new_message)
 
     @commands.Cog.listener()
     async def on_message_delete(self, message: discord.Message):

shinobu/beacon/fluxer/driver.py

@@ -213,6 +213,8 @@ async def _to_fluxer_content(self, content: beacon_message.BeaconMessageContent,
 
         # Process reply
         # To not eat up too many embeds, we'll just convert the first valid reply only
+        is_pin: bool = content.type == beacon_message.BeaconMessageType.pins_add
+
         for reply_message_group in content.replies:
             # Find channel-specific reply
             # noinspection DuplicatedCode
@@ -237,13 +239,20 @@ async def _to_fluxer_content(self, content: beacon_message.BeaconMessageContent,
                 icon_url=reply_message.author.avatar_url if reply_message.author else None
             )
 
-            # Create content text display (if possible)
-            if reply_content:
-                # We'll cap content to 200 characters
-                if len(reply_content) > 200:
-                    reply_content = reply_content[:197] + "..."
-
-                reply_embed.description = reply_content
+            if is_pin:
+                reply_embed.set_author(
+                    name=f"\U0001F4CC Pinned a message from @{reply_author}",
+                    url=reply_url,
+                    icon_url=reply_message.author.avatar_url if reply_message.author else None
+                )
+            else:
+                # Create content text display (if possible)
+                if reply_content:
+                    # We'll cap content to 200 characters
+                    if len(reply_content) > 200:
+                        reply_content = reply_content[:197] + "..."
+
+                    reply_embed.description = reply_content
 
             # Append embed
             embeds.append(reply_embed)
@@ -511,3 +520,17 @@ async def _purge(self, messages: list[beacon_message.BeaconMessage]):
 
         # Delete messages
         await channel.delete_messages([int(message.id) for message in messages])
+
+    async def _pin(self, message: beacon_message.BeaconMessage):
+        channel: fluxer.Channel = self.bot.get_channel(int(message.channel.id))
+        message_obj = await channel.fetch_message(int(message.id))
+
+        # Delete message
+        await message_obj.pin()
+
+    async def _unpin(self, message: beacon_message.BeaconMessage):
+        channel: fluxer.Channel = self.bot.get_channel(int(message.channel.id))
+        message_obj = await channel.fetch_message(int(message.id))
+
+        # Delete message
+        await message_obj.unpin()

shinobu/beacon/models/driver.py

@@ -139,6 +139,14 @@ async def _delete(self, message: beacon_message.BeaconMessage):
         """Deletes a message."""
         raise BeaconDriverUnsupported()
 
+    async def _pin(self, message: beacon_message.BeaconMessage):
+        """Pins a message."""
+        raise BeaconDriverUnsupported()
+
+    async def _unpin(self, message: beacon_message.BeaconMessage):
+        """Unpins a message."""
+        raise BeaconDriverUnsupported()
+
     async def _purge(self, messages: list[beacon_message.BeaconMessage]):
         """Purges messages from a channel."""
         raise BeaconDriverUnsupported()
@@ -275,3 +283,23 @@ async def purge(self, messages: list[beacon_message.BeaconMessage]):
                 raise BeaconDriverChannelMismatch(channel_id, message.channel.id)
 
         return await self._purge(messages)
+
+    async def pin(self, message: beacon_message.BeaconMessage):
+        """Pins a message."""
+
+        # NOTE: You will need to overwrite BeaconDriver._pin for this to work.
+
+        if message.platform != self.platform:
+            raise BeaconDriverPlatformMismatch(message.platform)
+
+        return await self._pin(message)
+
+    async def unpin(self, message: beacon_message.BeaconMessage):
+        """Unpins a message."""
+
+        # NOTE: You will need to overwrite BeaconDriver._unpin for this to work.
+
+        if message.platform != self.platform:
+            raise BeaconDriverPlatformMismatch(message.platform)
+
+        return await self._unpin(message)

shinobu/beacon/models/message.py

@@ -16,19 +16,25 @@
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
+from enum import Enum
 from shinobu.beacon.models import (content as beacon_content, abc, user as beacon_user, channel as beacon_channel,
                                    server as beacon_server, webhook as beacon_webhook, file as beacon_file,
                                    messageable as beacon_messageable)
 
+class BeaconMessageType(Enum):
+    default = 0
+    pins_add = 1
+
 class BeaconMessageContent:
     def __init__(self, original_id: str, original_channel_id: str, original_platform: str,
-                 blocks: dict[str, beacon_content.BeaconContentBlock],
+                 blocks: dict[str, beacon_content.BeaconContentBlock], message_type: BeaconMessageType | None = None,
                  files: list[beacon_file.BeaconFile] | None = None, replies: list['BeaconMessageGroup'] | None = None,
                  reply_content: str | dict[str, int] | None = None,
                  reply_attachments: int | dict[str, int] | None = None, suppress_embeds: bool = False):
         self._original_id: str = original_id
         self._original_channel_id: str = original_channel_id
         self._original_platform: str = original_platform
+        self._type: BeaconMessageType = message_type or BeaconMessageType.default
         self._blocks: dict[str, beacon_content.BeaconContentBlock] = blocks
         self._files: list[beacon_file.BeaconFile] = files or []
         self._replies: list[BeaconMessageGroup] = replies or []
@@ -63,6 +69,10 @@ def original_channel_id(self) -> str:
     def original_platform(self) -> str:
         return self._original_platform
 
+    @property
+    def type(self) -> BeaconMessageType:
+        return self._type
+
     @property
     def blocks(self) -> dict[str, beacon_content.BeaconContentBlock]:
         return self._blocks