Implement moderation backend

Author: greeeen-dev

README.md

@@ -25,10 +25,12 @@ So I'm starting from a clean state and building a new bridge that better adapts
 that's also flexible and ready for the demands of tomorrow.
 
 ## Is Shinobu production-ready?
-**No.**
+No (with an asterisk).
 
-Although I am testing this in some communities, Shinobu should **not** be used for production use.
-It is still a heavy work in progress and many features are either missing or incomplete.
+Shinobu is still in early alpha and many features are missing or incomplete. However, it has been
+tested in some communities and it has shown to be reliable enough for day-to-day bridging.
+
+You can use Shinobu if you want, but please note support may be limited. Use at your own risk.
 
 ## Todo
 - [X] Shinobu Runtime (core, secrets manager, debug tools, etc)

shinobu/beacon/cogs/config.py

@@ -17,7 +17,7 @@
 """
 
 import discord
-from discord.ext import commands, bridge
+from discord.ext import bridge
 from shinobu.runtime.models import shinobu_cog
 from shinobu.beacon.protocol import beacon
 

shinobu/beacon/protocol/bans.py

@@ -0,0 +1,149 @@
+"""
+Shinobu - Converse from anywhere, anytime.
+Copyright (C) 2026-present  Green (@greeeen-dev)
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+import time
+from enum import Enum
+from shinobu.beacon.models import user as beacon_user, server as beacon_server
+
+class BeaconBanType(Enum):
+    unknown = 0
+    user = 1
+    server = 2
+
+    def __int__(self):
+        return self.value
+
+class BeaconBan:
+    """Represents a moderator.
+    Moderators can lock Spaces, ban users/servers, etc."""
+
+    def __init__(self, user_id: str, ban_type: BeaconBanType | int, platform: str | None = None,
+                 expiry: int | None = None):
+        self._id: str = user_id
+        self._type: BeaconBanType = ban_type if type(ban_type) is BeaconBanType else BeaconBanType(ban_type)
+        self._expiry: int | None = expiry
+        self._platform: str | None = platform
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def type(self) -> BeaconBanType:
+        return self._type
+
+    @property
+    def platform(self) -> str:
+        return self._platform
+
+    @property
+    def expiry(self) -> int | None:
+        return self._expiry
+
+    @property
+    def is_permanent(self) -> bool:
+        return self._expiry is None
+
+    @property
+    def expired(self) -> bool:
+        if self.is_permanent:
+            return False
+
+        return time.time() >= self.expiry
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "type": int(self.type),
+            "platform": self.platform,
+            "expiry": self.expiry
+        }
+
+class BeaconBanManager:
+    def __init__(self):
+        self._scheme_version: int = 1
+        self._bans: dict[str, BeaconBan] = {}
+
+    @property
+    def bans(self) -> list[BeaconBan]:
+        return list(self._bans.values())
+        return list(self._admins.values())
+
+    def add_ban(self, ban: BeaconBan):
+        """Adds a Beacon ban."""
+        self._bans.update({ban.id: ban})
+
+    def add_bans(self, bans: list[BeaconBan]):
+        """Adds Beacon bans."""
+
+        for ban in bans:
+            self.add_ban(ban)
+
+    def ban(self, user_or_server: beacon_user.BeaconUser | beacon_server.BeaconServer | str,
+            duration: int | None = None) -> int | None:
+        """Bans a user and returns the ban expiry unix time."""
+
+        # Get ban type, platform and ID
+        ban_type: BeaconBanType = BeaconBanType.unknown
+        ban_platform: str | None = None
+
+        if isinstance(user_or_server, beacon_user.BeaconUser):
+            ban_type = BeaconBanType.user
+            ban_id: str = user_or_server.id
+            ban_platform = user_or_server.platform
+        elif isinstance(user_or_server, beacon_server.BeaconServer):
+            ban_type = BeaconBanType.server
+            ban_id: str = user_or_server.id
+            ban_platform = user_or_server.platform
+        else:
+            ban_id: str = user_or_server
+
+        # Ban user or server
+        ban: BeaconBan = BeaconBan(ban_id, ban_type, ban_platform, round(time.time()) + duration)
+
+        if self.is_banned(user_or_server):
+            self._bans[ban.id] = ban
+        else:
+            self._bans.update({ban.id: ban})
+
+        return ban.expiry
+
+    def is_banned(self, user_or_server: beacon_user.BeaconUser | beacon_server.BeaconServer | str):
+        if isinstance(user_or_server, beacon_user.BeaconUser) or isinstance(user_or_server, beacon_server.BeaconServer):
+            user_or_server = user_or_server.id
+
+        if user_or_server in self._bans:
+            ban: BeaconBan = self._bans[user_or_server]
+            if ban.expired:
+                self.remove_ban(user_or_server)
+                return False
+            else:
+                return True
+        else:
+            return False
+
+    def remove_ban(self, ban_id: str):
+        self._bans.pop(ban_id)
+
+    def to_dict(self) -> dict:
+        data = {}
+
+        for ban, ban_obj in self._bans.items():
+            data[ban] = ban_obj.to_dict()
+
+        return data

shinobu/beacon/protocol/beacon.py

@@ -21,7 +21,8 @@
 from enum import Enum
 from discord.ext import bridge
 from shinobu.beacon.protocol import (drivers as beacon_drivers, spaces as beacon_spaces, messages as beacon_messages,
-                                     filters as beacon_filters, pausing as beacon_pausing)
+                                     filters as beacon_filters, pausing as beacon_pausing, moderators as beacon_mods,
+                                     bans as beacon_bans)
 from shinobu.beacon.models import (space as beacon_space, message as beacon_message, content as beacon_content,
                                    filter as beacon_filter, member as beacon_member, channel as beacon_channel,
                                    driver as beacon_driver, server as beacon_server, user as beacon_user)
@@ -39,6 +40,10 @@ class BeaconPlatformDisabled(Exception):
     def __init__(self, platform: str):
         super().__init__(f"The resource is not available because {platform} is disabled.")
 
+class BeaconIsBanned(Exception):
+    def __init__(self, user_or_server: str):
+        super().__init__(f"This action cannot be done as {user_or_server} is banned.")
+
 class BeaconCallback:
     def __init__(self, func, args: list | None = None, kwargs: dict | None = None):
         self._func = func
@@ -91,6 +96,8 @@ def __init__(self, bot: bridge.Bot, files_wrapper: fine_grained.FineGrainedSecur
         self._messages: beacon_messages.BeaconMessageCache = beacon_messages.BeaconMessageCache(self.__wrapper)
         self._filters: beacon_filters.BeaconFilterManager = beacon_filters.BeaconFilterManager()
         self._pausing: beacon_pausing.BeaconPauseManager = beacon_pausing.BeaconPauseManager()
+        self._moderators: beacon_mods.BeaconModManager = beacon_mods.BeaconModManager()
+        self._bans: beacon_bans.BeaconBanManager = beacon_bans.BeaconBanManager()
 
     @property
     def initialized(self) -> bool:
@@ -112,6 +119,14 @@ def spaces(self) -> beacon_spaces.BeaconSpaceManager:
     def messages(self) -> beacon_messages.BeaconMessageCache:
         return self._messages
 
+    @property
+    def moderators(self) -> beacon_mods.BeaconModManager:
+        return self._moderators
+
+    @property
+    def bans(self) -> beacon_bans.BeaconBanManager:
+        return self._bans
+
     @property
     def disabled_platforms(self) -> list[str]:
         return self._disabled_platforms
@@ -333,6 +348,33 @@ def _load_data(self):
 
             self.messages.add_message(group)
 
+        # Load moderators
+        if data.get("moderators"):
+            for _, mod_data in data["moderators"].get("moderators", {}).items():
+                moderator: beacon_mods.BeaconModerator = beacon_mods.BeaconModerator(
+                    user_id=mod_data["id"],
+                    platform=mod_data["platform"]
+                )
+                self.moderators.add_moderator(moderator)
+
+            for _, admin_data in data["moderators"].get("admins", {}).items():
+                admin: beacon_mods.BeaconAdmin = beacon_mods.BeaconAdmin(
+                    user_id=admin_data["id"],
+                    platform=admin_data["platform"]
+                )
+                self.moderators.add_admin(admin)
+
+        # Load bans
+        for ban_id, ban_data in data.get("bans", {}).items():
+            ban: beacon_bans.BeaconBan = beacon_bans.BeaconBan(
+                user_id=ban_id,
+                ban_type=ban_data.get("type", 0),
+                platform=ban_data.get("platform"),
+                expiry=ban_data.get("expiry")
+            )
+
+            self.bans.add_ban(ban)
+
         self._init = True
 
         # Add shutdown cleanup
@@ -350,6 +392,8 @@ def save_data(self):
         # Assemble data dict
         data: dict = {
             "spaces": self._spaces.to_dict(),
+            "moderators": self._moderators.to_dict(),
+            "bans": self._bans.to_dict(),
             "paused": self._pausing.to_dict(),
             "raw": self._data
         }
@@ -589,6 +633,14 @@ async def send(self, author: beacon_member.BeaconMember | beacon_member.BeaconPa
         if content.original_platform in self._disabled_platforms:
             raise BeaconPlatformDisabled(content.original_platform)
 
+        # Ensure user is not banned
+        if self.bans.is_banned(author):
+            raise BeaconIsBanned(author.id)
+
+        # Ensure server is not banned
+        if self.bans.is_banned(author.server):
+            raise BeaconIsBanned(author.server_id)
+
         # Ensure content is not empty
         if len(content.blocks) == 0 and len(content.files) == 0:
             return
@@ -704,6 +756,14 @@ async def edit(self, message: beacon_message.BeaconMessage, content: beacon_mess
         if content.original_platform in self._disabled_platforms:
             raise BeaconPlatformDisabled(content.original_platform)
 
+        # Ensure user is not banned
+        if self.bans.is_banned(message.author):
+            raise BeaconIsBanned(message.author.id)
+
+        # Ensure server is not banned
+        if self.bans.is_banned(message.server):
+            raise BeaconIsBanned(message.server.id)
+
         origin_driver: beacon_driver.BeaconDriver = self._drivers.get_driver(message.platform)
 
         # Get message metadata
@@ -772,6 +832,10 @@ async def delete(self, message: beacon_message.BeaconMessage):
         if message.platform in self._disabled_platforms:
             raise BeaconPlatformDisabled(message.platform)
 
+        # Ensure server is not banned
+        if self.bans.is_banned(message.server):
+            raise BeaconIsBanned(message.server.id)
+
         # Get message group
         message_group: beacon_message.BeaconMessageGroup = self.messages.get_group_from_message(message.id)
         if not message_group:
@@ -817,6 +881,10 @@ async def purge(self, messages: list[beacon_message.BeaconMessage]):
         if messages[0].platform in self._disabled_platforms:
             raise BeaconPlatformDisabled(messages[0].platform)
 
+        # Ensure server is not banned
+        if self.bans.is_banned(messages[0].server):
+            raise BeaconIsBanned(messages[0].server.id)
+
         # Get message groups
         message_groups: list[beacon_message.BeaconMessageGroup] = []
         for message in messages:
@@ -859,14 +927,22 @@ async def purge(self, messages: list[beacon_message.BeaconMessage]):
             await self.__bot.loop.run_in_executor(None, lambda: self.messages.remove_message_group(message_group))
 
     async def pin(self, message: beacon_message.BeaconMessage, unpin: bool = False):
-        """Pins a message sent to a Space."""
+        """Pins or unpins a message sent to a Space."""
 
         if not self.initialized:
             raise BeaconNotInit()
 
         if message.platform in self._disabled_platforms:
             raise BeaconPlatformDisabled(message.platform)
 
+        # Ensure user is not banned
+        if self.bans.is_banned(message.author):
+            raise BeaconIsBanned(message.author.id)
+
+        # Ensure server is not banned
+        if self.bans.is_banned(message.server):
+            raise BeaconIsBanned(message.server.id)
+
         # Get message group
         message_group: beacon_message.BeaconMessageGroup = self.messages.get_group_from_message(message.id)
         if not message_group:
@@ -901,5 +977,6 @@ async def pin(self, message: beacon_message.BeaconMessage, unpin: bool = False):
         await self._strategy_async(tasks, return_exceptions=not self.debug)
 
     async def unpin(self, message: beacon_message.BeaconMessage):
-        """Unpins a message sent to a Space."""
+        """Unpins a message sent to a Space.
+        Shorthand for Beacon.pin(message, unpin=True)"""
         return await self.pin(message, unpin=True)