netbox-toolkit-plugin 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

netbox_toolkit_plugin/forms.py

@@ -1,31 +1,33 @@
 from django import forms
-from django.utils.translation import gettext_lazy as _
+
+from dcim.models import Platform
 from netbox.forms import NetBoxModelForm
 from utilities.forms.fields import DynamicModelChoiceField
-from dcim.models import Platform
+
 from .models import Command, CommandLog
 
+
 class CommandForm(NetBoxModelForm):
     platform = DynamicModelChoiceField(
         queryset=Platform.objects.all(),
-        help_text="Platform this command is designed for (e.g., cisco_ios, cisco_nxos, generic)"
+        help_text="Platform this command is designed for (e.g., cisco_ios, cisco_nxos, generic)",
     )
-    
+
     class Meta:
         model = Command
-        fields = ('name', 'command', 'description', 'platform', 'command_type', 'tags')
+        fields = ("name", "command", "description", "platform", "command_type", "tags")
+
 
 class CommandLogForm(NetBoxModelForm):
     class Meta:
         model = CommandLog
-        fields = ('command', 'device', 'output', 'username')
+        fields = ("command", "device", "output", "username")
+
 
 class CommandExecutionForm(forms.Form):
     username = forms.CharField(
-        max_length=100,
-        help_text="Username for device authentication"
+        max_length=100, help_text="Username for device authentication"
     )
     password = forms.CharField(
-        widget=forms.PasswordInput,
-        help_text="Password for device authentication"
-    )
+        widget=forms.PasswordInput, help_text="Password for device authentication"
+    )

netbox_toolkit_plugin/migrations/0008_remove_parsed_data_storage.py

@@ -0,0 +1,26 @@
+# Generated migration to remove parsed data storage
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('netbox_toolkit_plugin', '0007_alter_commandlog_parsing_template'),
+    ]
+
+    operations = [
+        # Remove parsed data fields since we now parse fresh from raw output
+        migrations.RemoveField(
+            model_name='commandlog',
+            name='parsed_data',
+        ),
+        migrations.RemoveField(
+            model_name='commandlog',
+            name='parsing_success',
+        ),
+        migrations.RemoveField(
+            model_name='commandlog',
+            name='parsing_template',
+        ),
+    ]

netbox_toolkit_plugin/models.py

@@ -1,7 +1,6 @@
 from django.db import models
-from django.core.exceptions import ValidationError
+
 from netbox.models import NetBoxModel
-from dcim.models import Device
 
 
 class Command(NetBoxModel):
@@ -55,27 +54,13 @@ class CommandLog(NetBoxModel):
     username = models.CharField(max_length=100)
     execution_time = models.DateTimeField(auto_now_add=True)
 
-    # Execution details added in migration
+    # Execution details
     success = models.BooleanField(default=True)
     error_message = models.TextField(blank=True)
     execution_duration = models.FloatField(
         blank=True, null=True, help_text="Command execution time in seconds"
     )
 
-    # Parsing details for TextFSM
-    parsed_data = models.JSONField(
-        blank=True, null=True, help_text="Parsed structured data from command output"
-    )
-    parsing_success = models.BooleanField(
-        default=False, help_text="Whether the output was successfully parsed"
-    )
-    parsing_template = models.CharField(
-        max_length=255,
-        blank=True,
-        null=True,
-        help_text="Name of the TextFSM template used for parsing",
-    )
-
     def __str__(self):
         return f"{self.command} on {self.device}"
 

netbox_toolkit_plugin/navigation.py

@@ -11,18 +11,21 @@ menu = PluginMenu(
                 PluginMenuItem(
                     link="plugins:netbox_toolkit_plugin:command_list",
                     link_text="Commands",
+                    permissions=["netbox_toolkit_plugin.view_command"],
                     buttons=(
                         PluginMenuButton(
                             "plugins:netbox_toolkit_plugin:command_add",
                             "Add",
                             "mdi mdi-plus-thick",
                             ButtonColorChoices.GRAY,
+                            permissions=["netbox_toolkit_plugin.add_command"],
                         ),
                     ),
                 ),
                 PluginMenuItem(
                     link="plugins:netbox_toolkit_plugin:commandlog_list",
                     link_text="Command Logs",
+                    permissions=["netbox_toolkit_plugin.view_commandlog"],
                 ),
             ),
         ),

netbox_toolkit_plugin/search.py

@@ -1,21 +1,24 @@
 from netbox.search import SearchIndex
+
 from .models import Command, CommandLog
 
+
 class CommandIndex(SearchIndex):
     model = Command
     fields = (
-        ('name', 100),
-        ('command', 200),
-        ('description', 500),
+        ("name", 100),
+        ("command", 200),
+        ("description", 500),
     )
-    display_attrs = ('platform', 'command_type', 'description')
+    display_attrs = ("platform", "command_type", "description")
+
 
 class CommandLogIndex(SearchIndex):
     model = CommandLog
     fields = (
-        ('command__name', 100),
-        ('device__name', 150),
-        ('username', 200),
-        ('output', 1000),
+        ("command__name", 100),
+        ("device__name", 150),
+        ("username", 200),
+        ("output", 1000),
     )
-    display_attrs = ('command', 'device', 'success', 'execution_time')
+    display_attrs = ("command", "device", "success", "execution_time")

netbox_toolkit_plugin/services/__init__.py

@@ -4,4 +4,4 @@ from .command_service import CommandExecutionService
 from .device_service import DeviceService
 from .rate_limiting_service import RateLimitingService
 
-__all__ = ['CommandExecutionService', 'DeviceService', 'RateLimitingService']
+__all__ = ["CommandExecutionService", "DeviceService", "RateLimitingService"]

netbox_toolkit_plugin/services/command_service.py

@@ -1,16 +1,16 @@
 """Service for handling command execution on devices."""
 
 import traceback
-from typing import Optional, Any
+from typing import Any
 
 from dcim.models import Device
 
-from ..models import Command, CommandLog
-from ..connectors.factory import ConnectorFactory
 from ..connectors.base import CommandResult
+from ..connectors.factory import ConnectorFactory
 from ..connectors.netmiko_connector import NetmikoConnector
-from ..exceptions import DeviceConnectionError, CommandExecutionError
-from ..config import ToolkitSettings
+from ..exceptions import DeviceConnectionError
+from ..models import Command, CommandLog
+from ..settings import ToolkitSettings
 from ..utils.logging import get_toolkit_logger
 
 logger = get_toolkit_logger(__name__)
@@ -24,7 +24,7 @@ class CommandExecutionService:
 
     def execute_command_with_retry(
         self,
-        command: "PredefinedCommand",
+        command: "Command",
         device: Any,
         username: str,
         password: str,
@@ -231,7 +231,7 @@ class CommandExecutionService:
             success = False
             error_message = result.error_message or ""
 
-        # Create log entry with execution details
+        # Create log entry with execution details (raw output only)
         command_log = CommandLog.objects.create(
             command=command,
             device=device,
@@ -240,9 +240,6 @@ class CommandExecutionService:
             success=success,
             error_message=error_message,
             execution_duration=result.execution_time,
-            parsed_data=result.parsed_output,
-            parsing_success=result.parsing_success,
-            parsing_template=result.parsing_method,
         )
 
         if result.has_syntax_error:

netbox_toolkit_plugin/services/device_service.py

@@ -1,5 +1,4 @@
 """Service for device-related operations."""
-from typing import List, Optional
 
 from dcim.models import Device
 
@@ -8,80 +7,89 @@ from ..models import Command
 
 class DeviceService:
     """Service for device-related operations."""
-    
+
     @staticmethod
-    def get_available_commands(device: Device) -> List[Command]:
+    def get_available_commands(device: Device) -> list[Command]:
         """
         Get all commands available for a device based on its platform.
-        
+
         Args:
             device: The device to get commands for
-            
+
         Returns:
             List of available commands
         """
         if not device.platform:
             return []
-        
+
         commands = Command.objects.filter(platform=device.platform)
-        
+
         return list(commands)
-    
+
     @staticmethod
     def get_device_connection_info(device: Device) -> dict:
         """
         Get connection information for a device.
-        
+
         Args:
             device: The device to get connection info for
-            
+
         Returns:
             Dictionary with connection information
         """
-        hostname = str(device.primary_ip.address.ip) if device.primary_ip else device.name
+        hostname = (
+            str(device.primary_ip.address.ip) if device.primary_ip else device.name
+        )
         platform = str(device.platform).lower() if device.platform else None
-        
+
         info = {
-            'hostname': hostname,
-            'platform': platform,
-            'has_primary_ip': device.primary_ip is not None,
+            "hostname": hostname,
+            "platform": platform,
+            "has_primary_ip": device.primary_ip is not None,
         }
-        
+
         return info
-    
+
     @staticmethod
-    def validate_device_for_commands(device: Device) -> tuple[bool, Optional[str], dict]:
+    def validate_device_for_commands(
+        device: Device,
+    ) -> tuple[bool, str | None, dict]:
         """
         Validate if a device is ready for command execution.
-        
+
         Args:
             device: The device to validate
-            
+
         Returns:
             Tuple of (is_valid, error_message, validation_checks)
             validation_checks is a dict with check names as keys and booleans as values
         """
         # Initialize validation checks
         validation_checks = {
-            'has_platform': device.platform is not None,
-            'has_primary_ip': device.primary_ip is not None,
-            'has_hostname': bool(device.name),  # Check if device has a name
-            'platform_supported': False,        # Will be set below if platform exists
+            "has_platform": device.platform is not None,
+            "has_primary_ip": device.primary_ip is not None,
+            "has_hostname": bool(device.name),  # Check if device has a name
+            "platform_supported": False,  # Will be set below if platform exists
         }
-        
+
         # Additional logic for more complex checks
-        if validation_checks['has_platform']:
-            validation_checks['platform_supported'] = True  # If platform exists, we consider it supported
-        
+        if validation_checks["has_platform"]:
+            validation_checks["platform_supported"] = (
+                True  # If platform exists, we consider it supported
+            )
+
         # Determine overall validity and error message
         is_valid = True
         error_message = None
-        
-        if not validation_checks['has_platform']:
+
+        if not validation_checks["has_platform"]:
             is_valid = False
             error_message = "Device has no platform assigned"
-        elif not validation_checks['has_primary_ip'] and not validation_checks['has_hostname']:
+        elif (
+            not validation_checks["has_primary_ip"]
+            and not validation_checks["has_hostname"]
+        ):
             is_valid = False
             error_message = "Device has no primary IP address or hostname"
-        
+
         return is_valid, error_message, validation_checks

netbox_toolkit_plugin/services/rate_limiting_service.py

@@ -1,7 +1,8 @@
-from datetime import datetime, timedelta
-from django.utils import timezone
+from datetime import timedelta
+
 from django.conf import settings
-from django.contrib.auth.models import User, Group
+from django.utils import timezone
+
 from ..models import CommandLog
 
 

netbox_toolkit_plugin/{config.py → settings.py}

@@ -1,8 +1,18 @@
 """Configuration settings for the NetBox Toolkit plugin."""
 
-from typing import Dict, Any
+from typing import Any
+
 from django.conf import settings
 
+# Plugin metadata - required by NetBox's plugin discovery system
+__version__ = "0.1.1"
+__author__ = "Andy Norwood"
+
+# Make these available as module-level attributes for NetBox's plugin system
+version = __version__
+author = __author__
+release_track = "stable"  # or "beta", "alpha" - indicates the release track
+
 
 class ToolkitSettings:
     """Configuration class for toolkit settings."""
@@ -104,7 +114,7 @@ class ToolkitSettings:
     }
 
     @classmethod
-    def get_fast_test_timeouts(cls) -> Dict[str, int]:
+    def get_fast_test_timeouts(cls) -> dict[str, int]:
         """Get fast connection test timeouts for initial viability testing."""
         return cls.FAST_TEST_TIMEOUTS.copy()
 
@@ -117,7 +127,7 @@ class ToolkitSettings:
         )
 
     @classmethod
-    def get_timeouts_for_device(cls, device_type_model: str = "") -> Dict[str, int]:
+    def get_timeouts_for_device(cls, device_type_model: str = "") -> dict[str, int]:
         """Get timeout configuration for a specific device type."""
         timeouts = cls.DEFAULT_TIMEOUTS.copy()
 
@@ -140,17 +150,17 @@ class ToolkitSettings:
         return cls.PLATFORM_ALIASES.get(platform_lower, platform_lower)
 
     @classmethod
-    def get_ssh_options(cls) -> Dict[str, Any]:
+    def get_ssh_options(cls) -> dict[str, Any]:
         """Get SSH transport options."""
         return cls.SSH_TRANSPORT_OPTIONS.copy()
 
     @classmethod
-    def get_retry_config(cls) -> Dict[str, int]:
+    def get_retry_config(cls) -> dict[str, int]:
         """Get retry configuration."""
         return cls.RETRY_CONFIG.copy()
 
     @classmethod
-    def get_ssh_transport_options(cls) -> Dict[str, Any]:
+    def get_ssh_transport_options(cls) -> dict[str, Any]:
         """Get SSH transport options for Scrapli."""
         user_config = getattr(settings, "PLUGINS_CONFIG", {}).get(
             "netbox_toolkit_plugin", {}
@@ -158,7 +168,7 @@ class ToolkitSettings:
         return {**cls.SSH_TRANSPORT_OPTIONS, **user_config.get("ssh_options", {})}
 
     @classmethod
-    def get_netmiko_config(cls) -> Dict[str, Any]:
+    def get_netmiko_config(cls) -> dict[str, Any]:
         """Get Netmiko configuration for fallback connections."""
         user_config = getattr(settings, "PLUGINS_CONFIG", {}).get(
             "netbox_toolkit_plugin", {}