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

netbox_toolkit_plugin/api/views/command_logs.py

@@ -1,29 +1,33 @@
 """
 API ViewSet for CommandLog resources
 """
-from rest_framework import status
-from rest_framework.decorators import action
-from rest_framework.response import Response
-from django.utils import timezone
+
 from datetime import timedelta
+
 from django.db.models import Count, Q
 from django.http import HttpResponse
-from drf_spectacular.utils import extend_schema_view
+from django.utils import timezone
+
 from netbox.api.viewsets import NetBoxModelViewSet
 
-from ... import models, filtersets
-from ..serializers import CommandLogSerializer
+from drf_spectacular.utils import extend_schema_view
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ... import filtersets, models
 from ..mixins import APIResponseMixin
 from ..schemas import (
-    COMMAND_LOG_LIST_SCHEMA,
-    COMMAND_LOG_RETRIEVE_SCHEMA,
     COMMAND_LOG_CREATE_SCHEMA,
-    COMMAND_LOG_UPDATE_SCHEMA,
-    COMMAND_LOG_PARTIAL_UPDATE_SCHEMA,
     COMMAND_LOG_DESTROY_SCHEMA,
-    COMMAND_LOG_STATISTICS_SCHEMA,
     COMMAND_LOG_EXPORT_SCHEMA,
+    COMMAND_LOG_LIST_SCHEMA,
+    COMMAND_LOG_PARTIAL_UPDATE_SCHEMA,
+    COMMAND_LOG_RETRIEVE_SCHEMA,
+    COMMAND_LOG_STATISTICS_SCHEMA,
+    COMMAND_LOG_UPDATE_SCHEMA,
 )
+from ..serializers import CommandLogSerializer
 
 
 @extend_schema_view(
@@ -39,132 +43,135 @@ class CommandLogViewSet(NetBoxModelViewSet, APIResponseMixin):
     serializer_class = CommandLogSerializer
     filterset_class = filtersets.CommandLogFilterSet
     # NetBox automatically handles object-based permissions - no need for explicit permission_classes
-    
+
     def get_queryset(self):
         """NetBox will automatically filter based on user's ObjectPermissions"""
         return super().get_queryset()
-    
+
     @COMMAND_LOG_STATISTICS_SCHEMA
-    @action(detail=False, methods=['get'], url_path='statistics')
+    @action(detail=False, methods=["get"], url_path="statistics")
     def statistics(self, request):
         """Get command execution statistics"""
         queryset = self.get_queryset()
-        
+
         # Basic stats
         total_logs = queryset.count()
         successful_logs = queryset.filter(success=True).count()
         success_rate = (successful_logs / total_logs * 100) if total_logs > 0 else 0
-        
+
         # Last 24 hours stats
         last_24h = timezone.now() - timedelta(hours=24)
         recent_logs = queryset.filter(created__gte=last_24h)
         recent_total = recent_logs.count()
         recent_successful = recent_logs.filter(success=True).count()
         recent_failed = recent_total - recent_successful
-        
+
         # Top commands
         top_commands = (
-            queryset.values('command__name')
-            .annotate(count=Count('command'))
-            .order_by('-count')[:10]
+            queryset.values("command__name")
+            .annotate(count=Count("command"))
+            .order_by("-count")[:10]
         )
-        
+
         # Common errors (non-empty error messages)
         common_errors = (
-            queryset.filter(~Q(error_message=''), ~Q(error_message__isnull=True))
-            .values('error_message')
-            .annotate(count=Count('error_message'))
-            .order_by('-count')[:10]
+            queryset.filter(~Q(error_message=""), ~Q(error_message__isnull=True))
+            .values("error_message")
+            .annotate(count=Count("error_message"))
+            .order_by("-count")[:10]
         )
-        
+
         return Response({
-            'total_logs': total_logs,
-            'success_rate': round(success_rate, 2),
-            'last_24h': {
-                'total': recent_total,
-                'successful': recent_successful,
-                'failed': recent_failed
+            "total_logs": total_logs,
+            "success_rate": round(success_rate, 2),
+            "last_24h": {
+                "total": recent_total,
+                "successful": recent_successful,
+                "failed": recent_failed,
             },
-            'top_commands': [
-                {'command_name': item['command__name'], 'count': item['count']}
+            "top_commands": [
+                {"command_name": item["command__name"], "count": item["count"]}
                 for item in top_commands
             ],
-            'common_errors': [
-                {'error': item['error_message'][:100], 'count': item['count']}
+            "common_errors": [
+                {"error": item["error_message"][:100], "count": item["count"]}
                 for item in common_errors
-            ]
+            ],
         })
-    
+
     @COMMAND_LOG_EXPORT_SCHEMA
-    @action(detail=False, methods=['get'], url_path='export')
+    @action(detail=False, methods=["get"], url_path="export")
     def export(self, request):
         """Export command logs"""
         import csv
         from datetime import datetime
-        
-        export_format = request.query_params.get('format', 'json')
-        start_date = request.query_params.get('start_date')
-        end_date = request.query_params.get('end_date')
-        
+
+        export_format = request.query_params.get("format", "json")
+        start_date = request.query_params.get("start_date")
+        end_date = request.query_params.get("end_date")
+
         queryset = self.get_queryset()
-        
+
         # Apply date filters if provided
         if start_date:
             try:
-                start_date = datetime.strptime(start_date, '%Y-%m-%d').date()
+                start_date = datetime.strptime(start_date, "%Y-%m-%d").date()
                 queryset = queryset.filter(created__date__gte=start_date)
             except ValueError:
                 return Response(
-                    {'error': 'Invalid start_date format. Use YYYY-MM-DD.'},
-                    status=status.HTTP_400_BAD_REQUEST
+                    {"error": "Invalid start_date format. Use YYYY-MM-DD."},
+                    status=status.HTTP_400_BAD_REQUEST,
                 )
-        
+
         if end_date:
             try:
-                end_date = datetime.strptime(end_date, '%Y-%m-%d').date()
+                end_date = datetime.strptime(end_date, "%Y-%m-%d").date()
                 queryset = queryset.filter(created__date__lte=end_date)
             except ValueError:
                 return Response(
-                    {'error': 'Invalid end_date format. Use YYYY-MM-DD.'},
-                    status=status.HTTP_400_BAD_REQUEST
+                    {"error": "Invalid end_date format. Use YYYY-MM-DD."},
+                    status=status.HTTP_400_BAD_REQUEST,
                 )
-        
+
         # Limit export size for performance
         if queryset.count() > 10000:
             return Response(
-                {'error': 'Export too large. Please use date filters to reduce size.'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "Export too large. Please use date filters to reduce size."},
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
-        if export_format == 'csv':
+
+        if export_format == "csv":
             # CSV export
-            response = HttpResponse(content_type='text/csv')
-            response['Content-Disposition'] = 'attachment; filename="command_logs.csv"'
-            
+            response = HttpResponse(content_type="text/csv")
+            response["Content-Disposition"] = 'attachment; filename="command_logs.csv"'
+
             writer = csv.writer(response)
             writer.writerow([
-                'ID', 'Command', 'Device', 'User', 'Success', 
-                'Created', 'Execution Time', 'Error Message'
+                "ID",
+                "Command",
+                "Device",
+                "User",
+                "Success",
+                "Created",
+                "Execution Time",
+                "Error Message",
             ])
-            
-            for log in queryset.select_related('command', 'device', 'user'):
+
+            for log in queryset.select_related("command", "device", "user"):
                 writer.writerow([
                     log.id,
                     log.command.name,
                     log.device.name,
-                    log.user.username if log.user else 'Unknown',
+                    log.user.username if log.user else "Unknown",
                     log.success,
                     log.created.isoformat(),
                     log.execution_time,
-                    log.error_message or ''
+                    log.error_message or "",
                 ])
-            
+
             return response
-        
+
         else:
             # JSON export
             serializer = self.get_serializer(queryset, many=True)
-            return Response({
-                'count': queryset.count(),
-                'results': serializer.data
-            })
+            return Response({"count": queryset.count(), "results": serializer.data})

netbox_toolkit_plugin/api/views/commands.py

@@ -1,29 +1,32 @@
 """
 API ViewSet for Command resources
 """
-from rest_framework import status
-from rest_framework.decorators import action
-from rest_framework.response import Response
+
 from django.db import transaction
-from drf_spectacular.utils import extend_schema_view
+
 from dcim.models import Device
 from netbox.api.viewsets import NetBoxModelViewSet
 
-from ... import models, filtersets
+from drf_spectacular.utils import extend_schema_view
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+from ... import filtersets, models
 from ...services.command_service import CommandExecutionService
 from ...services.rate_limiting_service import RateLimitingService
-from ..serializers import CommandSerializer, CommandExecutionSerializer
 from ..mixins import APIResponseMixin, PermissionCheckMixin
 from ..schemas import (
-    COMMAND_LIST_SCHEMA,
-    COMMAND_RETRIEVE_SCHEMA,
+    COMMAND_BULK_EXECUTE_SCHEMA,
     COMMAND_CREATE_SCHEMA,
-    COMMAND_UPDATE_SCHEMA,
-    COMMAND_PARTIAL_UPDATE_SCHEMA,
     COMMAND_DESTROY_SCHEMA,
     COMMAND_EXECUTE_SCHEMA,
-    COMMAND_BULK_EXECUTE_SCHEMA,
+    COMMAND_LIST_SCHEMA,
+    COMMAND_PARTIAL_UPDATE_SCHEMA,
+    COMMAND_RETRIEVE_SCHEMA,
+    COMMAND_UPDATE_SCHEMA,
 )
+from ..serializers import CommandExecutionSerializer, CommandSerializer
 
 
 @extend_schema_view(
@@ -40,193 +43,197 @@ class CommandViewSet(NetBoxModelViewSet, APIResponseMixin, PermissionCheckMixin)
     filterset_class = filtersets.CommandFilterSet
     # Using custom RateLimitingService instead of generic API throttling
     # NetBox automatically handles object-based permissions - no need for explicit permission_classes
-    
+
     def get_queryset(self):
         """NetBox will automatically filter based on user's ObjectPermissions"""
         # NetBox's object-based permission system will automatically filter this queryset
         # based on the user's ObjectPermissions for 'view' action on Command objects
         return super().get_queryset()
-    
+
     @COMMAND_EXECUTE_SCHEMA
-    @action(detail=True, methods=['post'], url_path='execute')
+    @action(detail=True, methods=["post"], url_path="execute")
     def execute_command(self, request, pk=None):
         """Execute a command on a device via API"""
         command = self.get_object()
-        
+
         # Validate input using serializer
         execution_serializer = CommandExecutionSerializer(data=request.data)
         if not execution_serializer.is_valid():
             return Response(
-                {
-                    'error': 'Invalid input data',
-                    'details': execution_serializer.errors
-                },
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "Invalid input data", "details": execution_serializer.errors},
+                status=status.HTTP_400_BAD_REQUEST,
             )
-        
+
         validated_data = execution_serializer.validated_data
-        device_id = validated_data['device_id']
-        username = validated_data['username']
-        password = validated_data['password']
-        
+        device_id = validated_data["device_id"]
+        username = validated_data["username"]
+        password = validated_data["password"]
+
         # Get device object
         try:
             device = Device.objects.get(id=device_id)
         except Device.DoesNotExist:
             return Response(
-                {'error': f'Device with ID {device_id} not found'},
-                status=status.HTTP_404_NOT_FOUND
+                {"error": f"Device with ID {device_id} not found"},
+                status=status.HTTP_404_NOT_FOUND,
             )
-        
+
         # Check permissions based on command type using NetBox's object-based permissions
-        if command.command_type == 'config':
-            if not self._user_has_action_permission(request.user, command, 'execute_config'):
-                return Response(
-                    {'error': 'You do not have permission to execute configuration commands'}, 
-                    status=status.HTTP_403_FORBIDDEN
-                )
-        elif command.command_type == 'show':
-            if not self._user_has_action_permission(request.user, command, 'execute_show'):
+        if command.command_type == "config":
+            if not self._user_has_action_permission(
+                request.user, command, "execute_config"
+            ):
                 return Response(
-                    {'error': 'You do not have permission to execute show commands'}, 
-                    status=status.HTTP_403_FORBIDDEN
+                    {
+                        "error": "You do not have permission to execute configuration commands"
+                    },
+                    status=status.HTTP_403_FORBIDDEN,
                 )
-        
+        elif command.command_type == "show" and not self._user_has_action_permission(
+            request.user, command, "execute_show"
+        ):
+            return Response(
+                {"error": "You do not have permission to execute show commands"},
+                status=status.HTTP_403_FORBIDDEN,
+            )
+
         # Check custom rate limiting (device-specific with bypass rules)
         rate_limiting_service = RateLimitingService()
         rate_limit_check = rate_limiting_service.check_rate_limit(device, request.user)
-        
-        if not rate_limit_check['allowed']:
+
+        if not rate_limit_check["allowed"]:
             return Response(
                 {
-                    'error': 'Rate limit exceeded',
-                    'details': {
-                        'reason': rate_limit_check['reason'],
-                        'current_count': rate_limit_check['current_count'],
-                        'limit': rate_limit_check['limit'],
-                        'time_window_minutes': rate_limit_check['time_window_minutes']
-                    }
+                    "error": "Rate limit exceeded",
+                    "details": {
+                        "reason": rate_limit_check["reason"],
+                        "current_count": rate_limit_check["current_count"],
+                        "limit": rate_limit_check["limit"],
+                        "time_window_minutes": rate_limit_check["time_window_minutes"],
+                    },
                 },
-                status=status.HTTP_429_TOO_MANY_REQUESTS
+                status=status.HTTP_429_TOO_MANY_REQUESTS,
             )
-        
+
         # Execute command using the service
         command_service = CommandExecutionService()
         result = command_service.execute_command_with_retry(
             command, device, username, password, max_retries=1
         )
-        
+
         # Determine overall success - failed if either execution failed or syntax error detected
         overall_success = result.success and not result.has_syntax_error
-        
+
         # Prepare response data
         response_data = {
-            'success': overall_success,
-            'output': result.output,
-            'error_message': result.error_message,
-            'execution_time': result.execution_time,
-            'command': {
-                'id': command.id,
-                'name': command.name,
-                'command_type': command.command_type
+            "success": overall_success,
+            "output": result.output,
+            "error_message": result.error_message,
+            "execution_time": result.execution_time,
+            "command": {
+                "id": command.id,
+                "name": command.name,
+                "command_type": command.command_type,
             },
-            'device': {
-                'id': device.id,
-                'name': device.name
-            }
+            "device": {"id": device.id, "name": device.name},
         }
-        
+
         # Add syntax error information if detected
         if result.has_syntax_error:
-            response_data['syntax_error'] = {
-                'detected': True,
-                'type': result.syntax_error_type,
-                'vendor': result.syntax_error_vendor,
-                'guidance_provided': True
+            response_data["syntax_error"] = {
+                "detected": True,
+                "type": result.syntax_error_type,
+                "vendor": result.syntax_error_vendor,
+                "guidance_provided": True,
             }
         else:
-            response_data['syntax_error'] = {
-                'detected': False
-            }
-        
+            response_data["syntax_error"] = {"detected": False}
+
         # Add parsing information if available
         if result.parsing_success and result.parsed_output:
-            response_data['parsed_output'] = {
-                'success': True,
-                'method': result.parsing_method,
-                'data': result.parsed_output
+            response_data["parsed_output"] = {
+                "success": True,
+                "method": result.parsing_method,
+                "data": result.parsed_output,
             }
         else:
-            response_data['parsed_output'] = {
-                'success': False,
-                'method': None,
-                'error': result.parsing_error
+            response_data["parsed_output"] = {
+                "success": False,
+                "method": None,
+                "error": result.parsing_error,
             }
-        
+
         # Return appropriate status code
-        status_code = status.HTTP_200_OK if overall_success else status.HTTP_400_BAD_REQUEST
-        
+        status_code = (
+            status.HTTP_200_OK if overall_success else status.HTTP_400_BAD_REQUEST
+        )
+
         return Response(response_data, status=status_code)
-    
+
     @COMMAND_BULK_EXECUTE_SCHEMA
-    @action(detail=False, methods=['post'], url_path='bulk-execute')
+    @action(detail=False, methods=["post"], url_path="bulk-execute")
     def bulk_execute(self, request):
         """Execute multiple commands on multiple devices"""
-        executions = request.data.get('executions', [])
-        
+        executions = request.data.get("executions", [])
+
         if not executions:
             return Response(
-                {'error': 'No executions provided'},
-                status=status.HTTP_400_BAD_REQUEST
+                {"error": "No executions provided"}, status=status.HTTP_400_BAD_REQUEST
             )
-        
+
         results = []
-        
+
         with transaction.atomic():
             for i, execution_data in enumerate(executions):
                 try:
                     # Validate each execution
-                    command_id = execution_data.get('command_id')
-                    device_id = execution_data.get('device_id')
-                    username = execution_data.get('username')
-                    password = execution_data.get('password')
-                    
+                    command_id = execution_data.get("command_id")
+                    device_id = execution_data.get("device_id")
+                    username = execution_data.get("username")
+                    password = execution_data.get("password")
+
                     if not all([command_id, device_id, username, password]):
                         results.append({
-                            'execution_id': i + 1,
-                            'success': False,
-                            'error': 'Missing required fields'
+                            "execution_id": i + 1,
+                            "success": False,
+                            "error": "Missing required fields",
                         })
                         continue
-                    
+
                     # Get command and device objects
                     try:
                         command = models.Command.objects.get(id=command_id)
                         device = Device.objects.get(id=device_id)
                     except (models.Command.DoesNotExist, Device.DoesNotExist) as e:
                         results.append({
-                            'execution_id': i + 1,
-                            'success': False,
-                            'error': f'Object not found: {str(e)}'
+                            "execution_id": i + 1,
+                            "success": False,
+                            "error": f"Object not found: {str(e)}",
                         })
                         continue
-                    
+
                     # Check permissions
-                    action = 'execute_config' if command.command_type == 'config' else 'execute_show'
-                    if not self._user_has_action_permission(request.user, command, action):
+                    action = (
+                        "execute_config"
+                        if command.command_type == "config"
+                        else "execute_show"
+                    )
+                    if not self._user_has_action_permission(
+                        request.user, command, action
+                    ):
                         results.append({
-                            'execution_id': i + 1,
-                            'success': False,
-                            'error': 'Insufficient permissions'
+                            "execution_id": i + 1,
+                            "success": False,
+                            "error": "Insufficient permissions",
                         })
                         continue
-                    
+
                     # Execute command
                     command_service = CommandExecutionService()
                     result = command_service.execute_command_with_retry(
                         command, device, username, password, max_retries=1
                     )
-                    
+
                     # Create command log entry (this would typically be done by the service)
                     log_entry = models.CommandLog.objects.create(
                         command=command,
@@ -235,33 +242,32 @@ class CommandViewSet(NetBoxModelViewSet, APIResponseMixin, PermissionCheckMixin)
                         output=result.output,
                         error_message=result.error_message,
                         execution_time=result.execution_time,
-                        success=result.success and not result.has_syntax_error
+                        success=result.success and not result.has_syntax_error,
                     )
-                    
+
                     results.append({
-                        'execution_id': i + 1,
-                        'success': result.success and not result.has_syntax_error,
-                        'command_log_id': log_entry.id,
-                        'execution_time': result.execution_time
+                        "execution_id": i + 1,
+                        "success": result.success and not result.has_syntax_error,
+                        "command_log_id": log_entry.id,
+                        "execution_time": result.execution_time,
                     })
-                    
+
                 except Exception as e:
                     results.append({
-                        'execution_id': i + 1,
-                        'success': False,
-                        'error': f'Unexpected error: {str(e)}'
+                        "execution_id": i + 1,
+                        "success": False,
+                        "error": f"Unexpected error: {str(e)}",
                     })
-        
+
         # Generate summary
         total = len(results)
-        successful = sum(1 for r in results if r.get('success', False))
+        successful = sum(1 for r in results if r.get("success", False))
         failed = total - successful
-        
-        return Response({
-            'results': results,
-            'summary': {
-                'total': total,
-                'successful': successful,
-                'failed': failed
-            }
-        }, status=status.HTTP_200_OK)
+
+        return Response(
+            {
+                "results": results,
+                "summary": {"total": total, "successful": successful, "failed": failed},
+            },
+            status=status.HTTP_200_OK,
+        )