ENHANCEMENT:

- Punishment: informative events can be sent to a different channel now (or disabled)

CHANGES:
- Permission check for channels improved.

Author: karel26

core/const.py

@@ -15,7 +15,10 @@
     "MONTH",
     "TRAFFIC_LIGHTS",
     "SAVED_GAMES",
-    "DEFAULT_TAG"
+    "DEFAULT_TAG",
+    "SEND_ONLY_CHANNEL_PERMISSIONS",
+    "DEFAULT_CHANNEL_PERMISSIONS",
+    "FULL_MANAGE_CHANNEL_PERMISSIONS",
 ]
 
 METER_IN_FEET = 3.28084
@@ -67,3 +70,21 @@
     )[0]
 
 DEFAULT_TAG = 'DEFAULT'
+
+SEND_ONLY_CHANNEL_PERMISSIONS = {
+    "view_channel",
+    "send_messages",
+    "read_messages",
+    "read_message_history",
+    "add_reactions",
+}
+
+DEFAULT_CHANNEL_PERMISSIONS = SEND_ONLY_CHANNEL_PERMISSIONS | {
+    "attach_files",
+    "embed_links",
+    "manage_messages",
+}
+
+FULL_MANAGE_CHANNEL_PERMISSIONS = DEFAULT_CHANNEL_PERMISSIONS | {
+    "manage_channel",
+}

plugins/greenieboard/const.py

@@ -1,8 +1,8 @@
 GRADES = {
     "_OK_": {"rating": 5, "grade": "Perfect pass", "legend": "PERFECT"},
     "OK": {"rating": 4, "grade": "Minimum deviation with good correction", "color": "#29C248", "legend": "OK"},
-    "(OK)": {"rating": 3, "grade": "Reasonable deviation with average correction", "color": "#F2C038", "legend": "FAIR"},
-    "B": {"rating": 2.5, "grade": "Tailhook did not catch a wire, aircraft went around for another pass", "color": '#088199', "legend": "BOLTER"},
+    "(OK)": {"rating": 3, "grade": "Reasonable deviation with avg. correction", "color": "#F2C038", "legend": "FAIR"},
+    "B": {"rating": 2.5, "grade": "No wire-catch, go-around needed", "color": '#088199', "legend": "BOLTER"},
     "--": {"rating": 2, "grade": "No grade. Below average corrections but safe pass", "color": "#73481d", "legend": "NO GRADE"},
     "WO": {"rating": 1, "grade": "Wave-off", "color": "#000000", "legend": "WAVE OFF"},
     "C": {"rating": 0, "grade": "Cut. Unsafe, gross deviations inside the wave-off window", "color": "#CC0000", "legend": "CUT"},

plugins/greenieboard/db/update_v1.0.sql

@@ -1,4 +1,4 @@
 ALTER TABLE greenieboard ADD COLUMN IF NOT EXISTS mission_id INTEGER NOT NULL DEFAULT -1;
 ALTER TABLE greenieboard ADD COLUMN IF NOT EXISTS trapsheet TEXT;
 DELETE FROM greenieboard;
-INSERT INTO greenieboard (mission_id, player_ucid, unit_type, grade, comment, place, night, points, time) SELECT mission_id, init_id, init_type, grade, comment, place, FALSE, CASE WHEN grade = '_OK_' THEN 5 WHEN grade = 'OK' THEN 4 WHEN grade = '(OK)' THEN 3 WHEN grade = 'B' THEN 2.5 WHEN grade IN('---', 'OWO', 'WOP') THEN 2 WHEN grade IN ('WO', 'LIG') THEN 1 WHEN grade = 'C' THEN 0 END AS points, time FROM (SELECT mission_id, init_id, init_type, SUBSTRING(comment, 'LSO: GRADE:([_\(\)-BCKOW]{1,4})') AS grade, comment, place, time FROM missionstats WHERE event LIKE '%QUALITY%' AND init_type IS NOT NULL) AS landings;
+INSERT INTO greenieboard (mission_id, player_ucid, unit_type, grade, comment, place, night, points, time) SELECT mission_id, init_id, init_type, grade, comment, place, FALSE, CASE WHEN grade = '_OK_' THEN 5 WHEN grade = 'OK' THEN 4 WHEN grade = '(OK)' THEN 3 WHEN grade = 'B' THEN 2.5 WHEN grade IN('---', 'OWO', 'WOP') THEN 2 WHEN grade IN ('WO', 'LIG') THEN 1 WHEN grade = 'C' THEN 0 END AS points, time FROM (SELECT mission_id, init_id, init_type, SUBSTRING(comment, 'LSO: GRADE:([_\(\)-BCKOW]{1,4})') AS grade, comment, place, time FROM missionstats WHERE event LIKE '%QUALITY%' AND init_id IS NOT NULL) AS landings;

plugins/punishment/README.md

@@ -13,6 +13,7 @@ opt_plugins:
 The plugin itself is configured with a file named config/plugins/punishment.yaml. You'll find a sample in ./samples:
 ```yaml
 DEFAULT:
+  channel: 1122334455667788 # Optional: Channel where to post who was punished for what (default: admin channel, disable: -1).
   penalties:                # These are the penalty points to use.
   - event: kill             # If you team-kill a human player, you get 30 points, 18 in the case of an AI.
     human: 30

plugins/punishment/commands.py

@@ -4,7 +4,7 @@
 
 from contextlib import suppress
 from core import (Plugin, PluginRequiredError, utils, Player, Server, PluginInstallationError, command, DEFAULT_TAG,
-                  Report, get_translation)
+                  Report, get_translation, SEND_ONLY_CHANNEL_PERMISSIONS)
 from discord import app_commands
 from discord.app_commands import Range
 from discord.ext import tasks
@@ -42,7 +42,13 @@ async def cog_unload(self):
     async def punish(self, server: Server, ucid: str, punishment: dict, reason: str, points: float | None = None):
         player: Player = server.get_player(ucid=ucid)
         member = self.bot.get_member_by_ucid(ucid)
-        admin_channel = self.bot.get_admin_channel(server)
+        channel_id = self.get_config(server).get('channel')
+        if channel_id:
+            self.bot.check_channel(channel_id, SEND_ONLY_CHANNEL_PERMISSIONS)
+            channel = self.bot.get_channel(channel_id)
+        else:
+            channel = self.bot.get_admin_channel(server)
+
         if punishment['action'] == 'ban':
             # we must not punish for reslots here
             self.eventlistener.pending_kill.pop(ucid, None)
@@ -66,8 +72,8 @@ async def punish(self, server: Server, ucid: str, punishment: dict, reason: str,
                 message = _("Player with ucid {ucid} banned by {banned_by} for {reason}.").format(
                     ucid=ucid, banned_by=self.bot.member.name, reason=reason)
             # audit
-            if admin_channel:
-                await admin_channel.send("```" + message + "```")
+            if channel:
+                await channel.send("```" + message + "```")
             await self.bot.audit(message)
 
         # everything after that point can only be executed if players are active
@@ -114,8 +120,8 @@ async def punish(self, server: Server, ucid: str, punishment: dict, reason: str,
                                                                                                   points=points))
         if message:
             # audit
-            if admin_channel:
-                await admin_channel.send("```" + message + "```")
+            if channel:
+                await channel.send("```" + message + "```")
             await self.bot.audit(message)
 
     # TODO: change to pubsub

plugins/punishment/schemas/punishment_schema.yaml

@@ -12,6 +12,7 @@ schema;element_schema:
   nullable: false
   mapping:
     enabled: {type: bool, nullable: false}
+    channel: {type: int, nullable: false}
     penalties:
       type: seq
       nullable: false

services/bot/dcsserverbot.py

@@ -2,7 +2,8 @@
 import discord
 
 from aiohttp import ClientError
-from core import Channel, utils, Status, PluginError, Group, Node
+from core import Channel, utils, Status, PluginError, Group, Node, DEFAULT_CHANNEL_PERMISSIONS, \
+    SEND_ONLY_CHANNEL_PERMISSIONS
 from core.data.node import FatalException
 from core.listener import EventListener
 from core.services.registry import ServiceRegistry
@@ -126,42 +127,79 @@ def check_roles(self, roles: Iterable[str | int]):
             if not self.get_role(role):
                 self.log.error(f"  => Role {role} not found in your Discord!")
 
-    def check_channel(self, channel_id: int) -> bool:
+    @staticmethod
+    def _channel_path(channel: discord.abc.GuildChannel) -> str:
+        """
+        Helper: return 'category/channel' if the channel has a category,
+        otherwise just 'channel'.
+        """
+        # Use ASCII‑safe names in the log (just like the original code)
+        channel_name = channel.name.encode("utf-8", "replace").decode()
+
+        if channel.category:  # `channel.category` is a CategoryChannel or None
+            cat_name = channel.category.name.encode("ascii", "replace").decode()
+            return f"{cat_name}/{channel_name}"
+        return channel_name
+
+    def check_channel(
+        self,
+        channel_id: int,
+        permissions: Iterable[str] | None = None,
+    ) -> bool:
+        """
+        Verify that the bot has the *required* permissions on the given channel.
+
+        Parameters
+        ----------
+        channel_id : int
+            Discord channel ID. `-1` is treated as a “no‑check” marker.
+        permissions : Iterable[str] | None
+            Permission names to check for (e.g. ``'view_channel'``).
+            If omitted, the default set in ``const.DEFAULT_CHANNEL_PERMISSIONS`` is used.
+
+        Returns
+        -------
+        bool
+            ``True`` if *all* requested permissions are present; otherwise ``False``.
+        """
         if channel_id == -1:
+            # A sentinel value – we purposely skip the check.
             return True
+
         channel = self.get_channel(channel_id)
         if not channel:
-            self.log.error(f'No channel with ID {channel_id} found!')
+            self.log.error(f"No channel with ID {channel_id} found!")
             return False
-        channel_name = channel.name.encode(encoding='ASCII', errors='replace').decode()
-        # name changes of the status channel will only happen with the correct permission
-        ret = True
-        permissions = channel.permissions_for(self.member)
-        if not permissions.view_channel:
-            self.log.error(f'  => Permission "View Channel" missing for channel {channel_name}')
-            ret = False
-        if not permissions.send_messages:
-            self.log.error(f'  => Permission "Send Messages" missing for channel {channel_name}')
-            ret = False
-        if not permissions.read_messages:
-            self.log.error(f'  => Permission "Read Messages" missing for channel {channel_name}')
-            ret = False
-        if not permissions.read_message_history:
-            self.log.error(f'  => Permission "Read Message History" missing for channel {channel_name}')
-            ret = False
-        if not permissions.add_reactions:
-            self.log.error(f'  => Permission "Add Reactions" missing for channel {channel_name}')
-            ret = False
-        if not permissions.attach_files:
-            self.log.error(f'  => Permission "Attach Files" missing for channel {channel_name}')
-            ret = False
-        if not permissions.embed_links:
-            self.log.error(f'  => Permission "Embed Links" missing for channel {channel_name}')
-            ret = False
-        if not permissions.manage_messages:
-            self.log.error(f'  => Permission "Manage Messages" missing for channel {channel_name}')
-            ret = False
-        return ret
+
+        # Make a *copy* so that the caller can pass in a mutable list without
+        # accidentally mutating the defaults.
+        required_perms: set[str] = set(permissions or DEFAULT_CHANNEL_PERMISSIONS)
+
+        channel_name = self._channel_path(channel)
+        channel_perms = channel.permissions_for(self.member)
+
+        # ------------------------------------------------------------------
+        # Iterate over the permission names and flag missing ones.
+        # ------------------------------------------------------------------
+        has_all = True
+        for perm_name in required_perms:
+            # If the attribute does not exist on the Permission object we
+            # raise a clear error – this is a programming mistake, not a
+            # runtime Discord issue.
+            if not hasattr(channel_perms, perm_name):
+                raise AttributeError(
+                    f"Permission object has no attribute '{perm_name}'. "
+                    "Check the spelling against the discord.py docs."
+                )
+
+            if not getattr(channel_perms, perm_name):
+                self.log.error(
+                    f"  => Permission '{perm_name.replace('_', ' ').title()}' "
+                    f"missing for channel '{channel_name}'"
+                )
+                has_all = False
+
+        return has_all
 
     def get_channel(self, channel_id: int, /) -> Any:
         if channel_id == -1:
@@ -179,16 +217,22 @@ def get_role(self, role: str | int) -> discord.Role | None:
         else:
             return None
 
-    def check_channels(self, server: "Server"):
-        channels = ['status', 'chat']
+    def _check_server_channels(self, server: "Server"):
+        channels = {
+            'status': DEFAULT_CHANNEL_PERMISSIONS,
+            'chat': SEND_ONLY_CHANNEL_PERMISSIONS
+        }
         if not self.locals.get('channels', {}).get('admin'):
-            channels.append('admin')
+            channels['admin'] = DEFAULT_CHANNEL_PERMISSIONS
         if server.locals.get('coalitions'):
-            channels.extend(['red', 'blue'])
-        for c in channels:
+            channels |= {
+                'red': SEND_ONLY_CHANNEL_PERMISSIONS,
+                'blue': SEND_ONLY_CHANNEL_PERMISSIONS
+            }
+        for c, perms in channels.items():
             channel_id = int(server.channels[Channel(c)])
             if channel_id != -1:
-                self.check_channel(channel_id)
+                self.check_channel(channel_id, perms)
 
     async def on_ready(self):
         async def register_guild_name():
@@ -225,7 +269,7 @@ async def register_guild_name():
                 self.check_roles(roles)
                 # check channels in bot.yaml
                 for name, channel in self.locals.get('channels', {}).items():
-                    self.check_channel(int(channel))
+                    self.check_channel(int(channel), DEFAULT_CHANNEL_PERMISSIONS)
                 # check channels in servers.yaml
                 for server in self.servers.values():
                     if server.locals.get('coalitions'):
@@ -234,7 +278,7 @@ async def register_guild_name():
                         roles.add(server.locals['coalitions']['red_role'])
                         self.check_roles(roles)
                     try:
-                        self.check_channels(server)
+                        self._check_server_channels(server)
                     except KeyError:
                         self.log.error(f"  => Mandatory channel(s) missing for server {server.name} in servers.yaml!")