Feature/control section permissions (#4)

* Update README

* Add docker run to README

* Add permission based access for the list-container command - controlled via setting.json

* Update README with settings section - also reformat for better flow

* Update README - labels are necessary

* Update control-containers to work with the AllowedRoles section control

* Change control-container log statements for view filtering to debug

* Change list-containers to be ephemeral w/ 30 sec deletion

Author: thisismygithubok

README.md

@@ -6,6 +6,23 @@ A docker-based discord bot to control other docker containers on the host. Built
 <img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/thisismygithubok/DiscContainerController?color=brightgreen&style=for-the-badge">
 <img alt="GitHub" src="https://img.shields.io/github/license/thisismygithubok/DiscContainerController?style=for-the-badge"></p>
 
+## Slash Commands ##
+This bot has several slash commands to use:
+- /ping - does a simple check to see if the bot is online and responding
+- /list-containers - lists the containers on the host system
+- /control-container - this is an interative command:
+    - First: You choose a container
+    - Second: You choose an action of start, stop, or restart
+    - Third: The bot will reply to you with a mention message once the action has been completed.
+
+## Docker Run ##
+```
+docker run -e DISCORD_GUILD_ID=<your_guild_id> -e DISCORD_BOT_TOKEN=<your_bot_token> -e TZ=<your_tz> -v /var/run/docker.sock:/var/run/docker.sock -l section=<section_name> thisismynameok/disc-container-controller:latest
+```
+
+## Docker Compose ##
+You can find an example in [docker-compose-example.yml](https://github.com/thisismygithubok/DiscContainerController/blob/main/docker-compose-example.yml)
+
 ## Environment Variables ##
 - REQUIRED
     - DISCORD_GUILD_ID
@@ -19,27 +36,51 @@ A docker-based discord bot to control other docker containers on the host. Built
         - This is optional, but you can specify this for the container/logging output timezone
         - Must use IANA standard timezones
 
+```
+environment:
+    DISCORD_BOT_TOKEN: ${DISCORD_BOT_TOKEN}
+    DISCORD_GUILD_ID: ${DISCORD_GUILD_ID}
+    TZ: ${TZ}
+```
+
 ## Volumes ##
-You also need to mount the docker sock as a volume to the container to be able to control containers.
-- /var/run/docker.sock:/var/run/docker.sock
+You need to mount the docker sock as a volume to the container to be able to control containers. You also need to mount a config directory for the setting.json to be generated into
+```
+volumes:
+    - /var/run/docker.sock:/var/run/docker.sock
+    - ./config:config
+```
 
 ## Labels ##
-You can optionally add container labels called 'section' to categorize and list your containers in a more friendly manner.
-- Example
-    - labels: 
-        - section: "Game Servers"
-
-## Slash Commands ##
-This bot has several slash commands to use:
-- /ping - does a simple check to see if the bot is online and responding
-- /list-containers - lists the containers on the host system
-- /control-container - this is an interative command:
-    - First: You choose a container
-    - Second: You choose an action of start, stop, or restart
-    - Third: The bot will reply to you with a mention message once the action has been completed.
+You need to add container labels called 'section' to categorize and list your containers in a more friendly manner.
+```
+labels:
+    section: "Game Servers"
+```
 
-## Docker Compose ##
-You can find an example in [docker-compose-example.yml](https://github.com/thisismygithubok/DiscContainerController/blob/main/docker-compose-example.yml)
+## Settings ##
+A settings.json file will be generated in your mounted config folder.
+- AdminIDs - this is a discord user ID, and these IDs will have permissions to see/control all containers within all sections.
+- AllowedRoles - this is a dict of role IDs and the sections those roles are allowed to see/control
+- Sections - these are the sections you've defined via container labels. These are necessary to see/control containers.
+- Example:
+```
+{
+    "AdminIDs": [
+        "1234567890101010"
+    ],
+    "AllowedRoles": {
+        "0101010987654321": [
+            "Game Servers"
+        ]
+    },
+    "Sections": [
+        "Backend",
+        "Frontend",
+        "Game Servers"
+    ]
+}
+```
 
 ## Setting Up a Discord Bot ##
 1. Navigate to the [Discord Developer Portal](https://discord.com/developers/applications)

dockerfile

@@ -18,8 +18,11 @@ RUN pip3 install discord.py && pip3 install prettytable setuptools>=78.1.1
 RUN addgroup -S -g 988 docker && \
     adduser -S -D -H -h /src -s /sbin/nologin -G docker -u 1000 nonroot && \
     adduser nonroot docker && \
-    chown -R nonroot:docker /src /config /entrypoint.sh && \
-    chmod -R 755 /src /config /entrypoint.sh
+    mkdir -p /config && \
+    chown nonroot:docker /config && \
+    chmod 2775 /config && \
+    chown -R nonroot:docker /src /entrypoint.sh && \
+    chmod -R 755 /src /entrypoint.sh
 
 USER nonroot
 

src/cogs/control-containers.py

@@ -2,6 +2,7 @@
 import asyncio
 import discord
 import logging
+import json
 import subprocess
 from discord import app_commands
 from discord.ext import commands
@@ -28,38 +29,57 @@ def __init__(self, containers, timeout=30):
         super().__init__(timeout=timeout)
         self.containers = containers
         self.current_page = 0
-        self.items_per_page = 24  # Due to 25 list item limit
+        self.items_per_page = 24
         self.total_pages = (len(containers) - 1) // self.items_per_page + 1
+        
+        logger.debug(f"Creating pagination view with {len(containers)} containers")
+        
+        # Initialize without buttons first
+        self.prev_button = None
+        self.next_button = None
+        
         self.update_select_menu()
 
     def update_select_menu(self):
-        for item in self.children[:]:
-            if isinstance(item, discord.ui.Select):
-                self.remove_item(item)
+        self.clear_items()
+        
+        # Add the select menu
         start = self.current_page * self.items_per_page
         end = start + self.items_per_page
         current_containers = self.containers[start:end]
         select_menu = selectContainerName(current_containers)
         self.add_item(select_menu)
+        
+        # Add navigation buttons if needed
+        if len(self.containers) > self.items_per_page:
+            self.prev_button = discord.ui.Button(
+                label="Previous",
+                style=discord.ButtonStyle.gray,
+                disabled=(self.current_page == 0),
+                custom_id="prev"
+            )
+            self.next_button = discord.ui.Button(
+                label="Next",
+                style=discord.ButtonStyle.gray,
+                disabled=(self.current_page >= self.total_pages - 1),
+                custom_id="next"
+            )
+            
+            # Bind callback functions
+            self.prev_button.callback = self.prev_callback
+            self.next_button.callback = self.next_callback
+            
+            self.add_item(self.prev_button)
+            self.add_item(self.next_button)
 
-    @discord.ui.button(label="Previous", style=discord.ButtonStyle.gray, disabled=True)
-    async def prev_button(self, interaction: discord.Interaction, button: discord.ui.Button):
+    async def prev_callback(self, interaction: discord.Interaction):
         self.current_page = max(0, self.current_page - 1)
         self.update_select_menu()
-        button.disabled = self.current_page == 0
-        next_button = [x for x in self.children if isinstance(x, discord.ui.Button) and x.label == "Next"][0]
-        next_button.disabled = self.current_page >= self.total_pages - 1
-        
         await interaction.response.edit_message(view=self)
 
-    @discord.ui.button(label="Next", style=discord.ButtonStyle.gray)
-    async def next_button(self, interaction: discord.Interaction, button: discord.ui.Button):
+    async def next_callback(self, interaction: discord.Interaction):
         self.current_page = min(self.total_pages - 1, self.current_page + 1)
         self.update_select_menu()
-        button.disabled = self.current_page >= self.total_pages - 1
-        prev_button = [x for x in self.children if isinstance(x, discord.ui.Button) and x.label == "Previous"][0]
-        prev_button.disabled = self.current_page == 0
-        
         await interaction.response.edit_message(view=self)
 
 class selectAction(discord.ui.Select):
@@ -113,17 +133,6 @@ def __init__(self, containers):
         ]
         super().__init__(placeholder="Select a container", max_values=1, min_values=1, options=options)
 
-        containers = []
-        try:
-            result = subprocess.run(['docker', 'ps', '-a', '--format', '{{.Names}}'], capture_output=True, text=True, check=True)
-            if result.returncode == 0:
-                containers = result.stdout.strip().splitlines()
-                containers.sort()
-                logger.debug(f'Found containers: {containers}')
-            
-        except subprocess.CalledProcessError as e:
-            logger.error(f'Error executing docker command: {e}')
-
     async def callback(self, interaction: discord.Interaction):
         selected_container = self.values[0]
         await interaction.response.defer(ephemeral=True)
@@ -143,24 +152,85 @@ async def delete_after_delay():
 class controlContainers(commands.Cog):
     def __init__(self, bot):
         self.bot = bot
+        self.settings = self.load_settings()
+
+    def load_settings(self):
+        try:
+            with open('/config/settings.json', 'r') as f:
+                return json.load(f)
+        except Exception as e:
+            logger.error(f'Error loading settings: {e}')
+            return None
+        
+    def get_allowed_sections(self, user: discord.Member):
+        # Check if user is admin
+        if str(user.id) in self.settings.get('AdminIDs', []):
+            return self.settings.get('Sections', [])
+
+        # Get user's roles and their allowed sections
+        allowed_sections = set()
+        for role in user.roles:
+            role_sections = self.settings.get('AllowedRoles', {}).get(str(role.id), [])
+            allowed_sections.update(role_sections)
+
+        return list(allowed_sections)
 
     @app_commands.command(name='control-container', description='Start, Stop, or Restart the selected Docker container.')
     @app_commands.guilds(discord.Object(id=DISCORD_GUILD_ID)) # type: ignore
 
     async def controlContainer(self, interaction: discord.Interaction):
         try:
+            if not self.settings:
+                await interaction.response.send_message('Error: Settings not loaded', ephemeral=True)
+                return
+
+            # Get allowed sections for this user
+            allowed_sections = self.get_allowed_sections(interaction.user)
+            if not allowed_sections and str(interaction.user.id) not in self.settings.get('AdminIDs', []):
+                await interaction.response.send_message('You do not have permission to control any sections', ephemeral=True)
+                return
+
+            # Get all containers and filter by section
             result = subprocess.run(['docker', 'ps', '-a', '--format', '{{.Names}}'], 
-                                 capture_output=True, text=True, check=True)
-            if result.returncode == 0:
-                containers = result.stdout.strip().splitlines()
-                containers.sort()
-                logger.debug(f'Found containers: {containers}')
-                
-                view = ContainerPaginationView(containers)
-                await interaction.response.send_message(view=view, ephemeral=True)
-                await asyncio.sleep(30)
-                await interaction.delete_original_response()
-                
+                                capture_output=True, text=True, check=True)
+            
+            if result.returncode != 0:
+                await interaction.response.send_message(
+                    'Error retrieving container list - see service logs.',
+                    ephemeral=True
+                )
+                return
+
+            containers = []
+            all_containers = result.stdout.strip().splitlines()
+            
+            # Filter containers by section permissions
+            for container in all_containers:
+                if container:
+                    inspect = subprocess.run(
+                        ['docker', 'inspect', '--format', '{{.Config.Labels.section}}', container],
+                        capture_output=True, text=True, check=True
+                    )
+                    section = inspect.stdout.strip()
+                    section = section if section else "Uncategorized"
+                    
+                    # Only add container if user has permission for this section or is admin
+                    if section in allowed_sections or str(interaction.user.id) in self.settings.get('AdminIDs', []):
+                        containers.append(container)
+
+            if not containers:
+                await interaction.response.send_message('No containers available to control.', ephemeral=True)
+                return
+
+            containers.sort()
+            logger.debug(f'Creating view with {len(containers)} filtered containers')
+            view = ContainerPaginationView(containers)
+            logger.debug(f'Filtered containers by permission: {containers}')
+
+            await interaction.response.send_message(view=view, ephemeral=True)
+            await asyncio.sleep(30)
+            await interaction.delete_original_response()
+
         except subprocess.CalledProcessError as e:
             logger.error(f'Error executing docker command: {e}')
             await interaction.response.send_message(