netbox-maintenance-device 1.2.1__py3-none-any.whl

netbox_maintenance_device/__init__.py

@@ -0,0 +1,40 @@
+from netbox.plugins import PluginConfig
+from django.utils.translation import gettext_lazy as _
+
+class MaintenanceDeviceConfig(PluginConfig):
+    name = 'netbox_maintenance_device'
+    verbose_name = _('NetBox Device Maintenance')
+    description = 'Manage device preventive and corrective maintenance with multilingual support'
+    version = '1.2.1'
+    author = 'Diego Godoy'
+    author_email = 'diegoalex-gdy@outlook.com'
+    base_url = 'maintenance-device'
+    icon = 'mdi-wrench-cog'
+    
+    # Required NetBox version - Conservative range for this release
+    min_version = '4.4.0'
+    max_version = '4.4.99'
+    
+    # Default configurations
+    default_settings = {
+        'default_frequency_days': 30,
+        'auto_heal_database': True,  # Enable automatic database healing
+    }
+    
+    # Translation configuration
+    default_language = 'en'
+    locale_paths = ['locale']
+    
+    def ready(self):
+        """
+        Called when the plugin is ready. Perform any necessary initialization.
+        """
+        super().ready()
+        
+        # Note: Database auto-healing is handled by migrations and model operations
+        # to avoid issues during initial Django setup and collectstatic operations
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info("NetBox Maintenance Device v1.2.1 initialized successfully")
+
+config = MaintenanceDeviceConfig

netbox_maintenance_device/admin.py

@@ -0,0 +1,16 @@
+from django.contrib import admin
+from . import models
+
+@admin.register(models.MaintenancePlan)
+class MaintenancePlanAdmin(admin.ModelAdmin):
+    list_display = ['device', 'name', 'maintenance_type', 'frequency_days', 'is_active', 'created']
+    list_filter = ['maintenance_type', 'is_active', 'created']
+    search_fields = ['device__name', 'name', 'description']
+    ordering = ['device', 'name']
+
+@admin.register(models.MaintenanceExecution)
+class MaintenanceExecutionAdmin(admin.ModelAdmin):
+    list_display = ['maintenance_plan', 'scheduled_date', 'completed_date', 'status', 'technician']
+    list_filter = ['status', 'completed', 'scheduled_date']
+    search_fields = ['maintenance_plan__device__name', 'maintenance_plan__name', 'technician']
+    ordering = ['-scheduled_date']

netbox_maintenance_device/api/__init__.py

@@ -0,0 +1 @@
+# API module for netbox_maintenance_device plugin

netbox_maintenance_device/api/permissions.py

@@ -0,0 +1,65 @@
+"""
+Custom permissions for NetBox Maintenance Device API.
+
+This module defines custom permission classes for the API endpoints,
+following NetBox patterns and ensuring proper access control.
+"""
+
+from rest_framework import permissions
+
+
+class MaintenanceDevicePermissions(permissions.BasePermission):
+    """
+    Custom permissions for maintenance device operations.
+    
+    Provides granular control for maintenance device API operations
+    with proper object-level permissions.
+    """
+    
+    def has_permission(self, request, view):
+        """Check if user has permission for the requested action"""
+        if not request.user or not request.user.is_authenticated:
+            return False
+        
+        # Map HTTP methods to permission requirements
+        permission_map = {
+            'GET': 'view',
+            'POST': 'add',
+            'PUT': 'change',
+            'PATCH': 'change',
+            'DELETE': 'delete',
+        }
+        
+        required_action = permission_map.get(request.method, 'view')
+        
+        # Get the model name from the viewset
+        if hasattr(view, 'queryset') and view.queryset is not None:
+            model_name = view.queryset.model._meta.model_name
+            perm_name = f'netbox_maintenance_device.{required_action}_{model_name}'
+            return request.user.has_perm(perm_name)
+        
+        return True
+    
+    def has_object_permission(self, request, view, obj):
+        """Check object-level permissions"""
+        return self.has_permission(request, view)
+
+
+class CanScheduleMaintenance(permissions.BasePermission):
+    """Permission to schedule maintenance executions"""
+    
+    def has_permission(self, request, view):
+        """Check if user has permission to schedule maintenance"""
+        return (request.user and 
+                request.user.is_authenticated and 
+                request.user.has_perm('netbox_maintenance_device.add_maintenanceexecution'))
+
+
+class CanCompleteMaintenance(permissions.BasePermission):
+    """Permission to complete maintenance executions"""
+    
+    def has_permission(self, request, view):
+        """Check if user has permission to complete maintenance"""
+        return (request.user and 
+                request.user.is_authenticated and 
+                request.user.has_perm('netbox_maintenance_device.change_maintenanceexecution'))

netbox_maintenance_device/api/serializers.py

@@ -0,0 +1,217 @@
+from rest_framework import serializers
+from netbox.api.serializers import NetBoxModelSerializer, WritableNestedSerializer
+from netbox_maintenance_device import models
+from django.utils import timezone
+
+
+class DeviceNestedSerializer(WritableNestedSerializer):
+    """Nested serializer for Device references - NetBox 4.4.x compatible"""
+    
+    class Meta:
+        # Import Device model at class level
+        from dcim import models as dcim_models
+        model = dcim_models.Device
+        fields = ['id', 'url', 'display', 'name']
+
+
+class NestedMaintenancePlanSerializer(WritableNestedSerializer):
+    """Nested serializer for MaintenancePlan references"""
+    url = serializers.HyperlinkedIdentityField(
+        view_name='plugins-api:netbox_maintenance_device-api:maintenanceplan-detail'
+    )
+
+    class Meta:
+        model = models.MaintenancePlan
+        fields = ['id', 'url', 'display', 'name', 'maintenance_type']
+
+
+class NestedMaintenanceExecutionSerializer(WritableNestedSerializer):
+    """Nested serializer for MaintenanceExecution references"""
+    url = serializers.HyperlinkedIdentityField(
+        view_name='plugins-api:netbox_maintenance_device-api:maintenanceexecution-detail'
+    )
+
+    class Meta:
+        model = models.MaintenanceExecution
+        fields = ['id', 'url', 'display', 'scheduled_date', 'status']
+
+
+class MaintenancePlanSerializer(NetBoxModelSerializer):
+    """Complete serializer for MaintenancePlan with all relationships and computed fields"""
+    
+    url = serializers.HyperlinkedIdentityField(
+        view_name='plugins-api:netbox_maintenance_device-api:maintenanceplan-detail'
+    )
+    
+    # Nested relationships
+    device = DeviceNestedSerializer()
+    executions = NestedMaintenanceExecutionSerializer(many=True, read_only=True)
+    
+    # Computed fields
+    execution_count = serializers.IntegerField(read_only=True)
+    next_maintenance_date = serializers.DateTimeField(read_only=True)
+    is_overdue = serializers.BooleanField(read_only=True)
+    days_until_due = serializers.IntegerField(read_only=True)
+    last_execution_date = serializers.DateTimeField(read_only=True)
+    
+    class Meta:
+        model = models.MaintenancePlan
+        fields = [
+            'id', 'url', 'display', 'device', 'name', 'description', 
+            'maintenance_type', 'frequency_days', 'is_active',
+            'created', 'last_updated', 'custom_field_data', 'tags',
+            # Relationships
+            'executions', 'execution_count',
+            # Computed fields
+            'next_maintenance_date', 'is_overdue', 'days_until_due',
+            'last_execution_date'
+        ]
+        
+    def validate_frequency_days(self, value):
+        """Validate frequency days is positive and reasonable"""
+        if value <= 0:
+            raise serializers.ValidationError("Frequency must be greater than 0 days")
+        if value > 3650:  # 10 years
+            raise serializers.ValidationError("Frequency cannot exceed 3650 days (10 years)")
+        return value
+    
+    def validate(self, data):
+        """Additional model-level validations"""
+        device = data.get('device')
+        name = data.get('name')
+        
+        # Check for duplicate plan names per device (excluding current instance)
+        if device and name:
+            existing_plans = models.MaintenancePlan.objects.filter(
+                device=device, name=name
+            )
+            if self.instance:
+                existing_plans = existing_plans.exclude(pk=self.instance.pk)
+            
+            if existing_plans.exists():
+                raise serializers.ValidationError({
+                    'name': f"A maintenance plan with name '{name}' already exists for this device."
+                })
+        
+        return data
+    
+    def to_representation(self, instance):
+        """Add computed fields to the representation"""
+        data = super().to_representation(instance)
+        
+        # Add computed fields
+        data['execution_count'] = instance.executions.count()
+        data['next_maintenance_date'] = instance.get_next_maintenance_date()
+        data['is_overdue'] = instance.is_overdue()
+        data['days_until_due'] = instance.days_until_due()
+        
+        # Add last execution date
+        last_execution = instance.executions.filter(completed=True).order_by('-completed_date').first()
+        data['last_execution_date'] = last_execution.completed_date if last_execution else None
+        
+        return data
+
+
+class MaintenanceExecutionSerializer(NetBoxModelSerializer):
+    """Complete serializer for MaintenanceExecution with all relationships and validations"""
+    
+    url = serializers.HyperlinkedIdentityField(
+        view_name='plugins-api:netbox_maintenance_device-api:maintenanceexecution-detail'
+    )
+    
+    # Nested relationships
+    maintenance_plan = NestedMaintenancePlanSerializer()
+    
+    # Computed fields
+    device = serializers.CharField(source='maintenance_plan.device.name', read_only=True)
+    device_id = serializers.IntegerField(source='maintenance_plan.device.id', read_only=True)
+    plan_name = serializers.CharField(source='maintenance_plan.name', read_only=True)
+    duration_days = serializers.SerializerMethodField()
+    
+    class Meta:
+        model = models.MaintenanceExecution
+        fields = [
+            'id', 'url', 'display', 'maintenance_plan', 'scheduled_date', 
+            'completed_date', 'status', 'notes', 'technician', 'completed',
+            'created', 'last_updated', 'custom_field_data', 'tags',
+            # Computed fields
+            'device', 'device_id', 'plan_name', 'duration_days'
+        ]
+    
+    def get_duration_days(self, obj):
+        """Calculate duration between scheduled and completed dates"""
+        if obj.scheduled_date and obj.completed_date:
+            delta = obj.completed_date - obj.scheduled_date
+            return delta.days
+        return None
+    
+    def validate_scheduled_date(self, value):
+        """Validate scheduled date is not too far in the past"""
+        if value and value.date() < (timezone.now().date() - timezone.timedelta(days=365)):
+            raise serializers.ValidationError("Scheduled date cannot be more than 1 year in the past")
+        return value
+    
+    def validate_completed_date(self, value):
+        """Validate completed date is not in the future"""
+        if value and value.date() > timezone.now().date():
+            raise serializers.ValidationError("Completed date cannot be in the future")
+        return value
+    
+    def validate(self, data):
+        """Additional model-level validations"""
+        scheduled_date = data.get('scheduled_date')
+        completed_date = data.get('completed_date')
+        status = data.get('status')
+        
+        # If status is completed, completed_date should be set
+        if status == 'completed' and not completed_date:
+            raise serializers.ValidationError({
+                'completed_date': "Completed date is required when status is 'completed'."
+            })
+        
+        # If completed_date is set, status should be completed
+        if completed_date and status != 'completed':
+            raise serializers.ValidationError({
+                'status': "Status must be 'completed' when completed date is set."
+            })
+        
+        # Completed date should not be before scheduled date
+        if scheduled_date and completed_date and completed_date < scheduled_date:
+            raise serializers.ValidationError({
+                'completed_date': "Completed date cannot be before scheduled date."
+            })
+        
+        return data
+
+
+# Bulk operation serializers for efficient operations
+class BulkMaintenancePlanSerializer(serializers.ListSerializer):
+    """Bulk operations for MaintenancePlan"""
+    
+    def create(self, validated_data):
+        """Bulk create maintenance plans"""
+        return [models.MaintenancePlan.objects.create(**attrs) for attrs in validated_data]
+    
+    def update(self, instance_list, validated_data):
+        """Bulk update maintenance plans"""
+        plan_mapping = {plan.id: plan for plan in instance_list}
+        
+        updated_plans = []
+        for attrs in validated_data:
+            plan_id = attrs.pop('id', None)
+            if plan_id and plan_id in plan_mapping:
+                plan = plan_mapping[plan_id]
+                for key, value in attrs.items():
+                    setattr(plan, key, value)
+                plan.save()
+                updated_plans.append(plan)
+        
+        return updated_plans
+
+
+class BulkMaintenanceExecutionSerializer(serializers.ListSerializer):
+    """Bulk operations for MaintenanceExecution"""
+    
+    def create(self, validated_data):
+        """Bulk create maintenance executions"""
+        return [models.MaintenanceExecution.objects.create(**attrs) for attrs in validated_data]

netbox_maintenance_device/api/urls.py

@@ -0,0 +1,60 @@
+from django.urls import path, include
+from netbox.api.routers import NetBoxRouter
+from . import views
+
+app_name = 'netbox_maintenance_device-api'
+
+# Main API router for CRUD operations
+router = NetBoxRouter()
+
+# Register main viewsets
+router.register('maintenance-plans', views.MaintenancePlanViewSet, basename='maintenanceplan')
+router.register('maintenance-executions', views.MaintenanceExecutionViewSet, basename='maintenanceexecution')
+
+# Include all router URLs
+urlpatterns = [
+    # Main API routes (includes all CRUD operations and custom actions)
+    path('', include(router.urls)),
+    
+    # Additional custom endpoints can be added here if needed
+    # Example: path('reports/', views.MaintenanceReportView.as_view(), name='maintenance-reports'),
+]
+
+# URL patterns summary for documentation:
+# 
+# MaintenancePlan endpoints:
+# GET    /api/plugins/netbox-maintenance-device/maintenance-plans/           - List all plans
+# POST   /api/plugins/netbox-maintenance-device/maintenance-plans/           - Create new plan
+# GET    /api/plugins/netbox-maintenance-device/maintenance-plans/{id}/      - Get specific plan
+# PUT    /api/plugins/netbox-maintenance-device/maintenance-plans/{id}/      - Update plan (full)
+# PATCH  /api/plugins/netbox-maintenance-device/maintenance-plans/{id}/      - Update plan (partial)
+# DELETE /api/plugins/netbox-maintenance-device/maintenance-plans/{id}/      - Delete plan
+# 
+# Custom MaintenancePlan actions:
+# POST   /api/plugins/netbox-maintenance-device/maintenance-plans/{id}/schedule-maintenance/  - Schedule execution
+# GET    /api/plugins/netbox-maintenance-device/maintenance-plans/overdue/                    - Get overdue plans
+# GET    /api/plugins/netbox-maintenance-device/maintenance-plans/upcoming/                   - Get upcoming plans
+# GET    /api/plugins/netbox-maintenance-device/maintenance-plans/statistics/                 - Get plan statistics
+# 
+# MaintenanceExecution endpoints:
+# GET    /api/plugins/netbox-maintenance-device/maintenance-executions/      - List all executions
+# POST   /api/plugins/netbox-maintenance-device/maintenance-executions/      - Create new execution
+# GET    /api/plugins/netbox-maintenance-device/maintenance-executions/{id}/ - Get specific execution
+# PUT    /api/plugins/netbox-maintenance-device/maintenance-executions/{id}/ - Update execution (full)
+# PATCH  /api/plugins/netbox-maintenance-device/maintenance-executions/{id}/ - Update execution (partial)
+# DELETE /api/plugins/netbox-maintenance-device/maintenance-executions/{id}/ - Delete execution
+# 
+# Custom MaintenanceExecution actions:
+# POST   /api/plugins/netbox-maintenance-device/maintenance-executions/{id}/complete/         - Mark as completed
+# POST   /api/plugins/netbox-maintenance-device/maintenance-executions/{id}/cancel/           - Cancel execution
+# GET    /api/plugins/netbox-maintenance-device/maintenance-executions/pending/               - Get pending executions
+# GET    /api/plugins/netbox-maintenance-device/maintenance-executions/overdue-executions/    - Get overdue executions
+# GET    /api/plugins/netbox-maintenance-device/maintenance-executions/statistics/            - Get execution statistics
+#
+# All endpoints support:
+# - Filtering via query parameters (see FilterSets in views.py)
+# - Ordering via ?ordering=field_name
+# - Search via ?q=search_term
+# - Pagination via ?limit=N&offset=N
+# - Field selection via ?fields=field1,field2
+# - Format selection via ?format=json|api (HTML browsable API)