Closes #85, #120: Add module support to SupportContractAssignment

Add ability to assign support contracts to hardware modules (linecards),
extending the existing device assignment functionality.

Changes:
- Add `module` FK to SupportContractAssignment model
- Form uses TabbedGroups with "Hardware" (device + module) and "License" tabs
- Module filters device choices via query_params
- Auto-populate device from module.device or license.device
- Validate device matches module.device and license.device when both set
- Add module to API serializer, GraphQL type, filterset, table, and filter form
- Remove custom template in favor of NetBox's native fieldset rendering

Author: jsenecal

netbox_lifecycle/api/_serializers/contract.py

@@ -1,6 +1,6 @@
 from rest_framework import serializers
 
-from dcim.api.serializers_.devices import DeviceSerializer
+from dcim.api.serializers_.devices import DeviceSerializer, ModuleSerializer
 from dcim.api.serializers_.manufacturers import ManufacturerSerializer
 from netbox.api.serializers import NetBoxModelSerializer
 from netbox_lifecycle.api._serializers.license import LicenseAssignmentSerializer
@@ -85,6 +85,7 @@ class SupportContractAssignmentSerializer(NetBoxModelSerializer):
     contract = SupportContractSerializer(nested=True)
     sku = SupportSKUSerializer(nested=True, required=False, allow_null=True)
     device = DeviceSerializer(nested=True, required=False, allow_null=True)
+    module = ModuleSerializer(nested=True, required=False, allow_null=True)
     license = LicenseAssignmentSerializer(nested=True, required=False, allow_null=True)
 
     class Meta:
@@ -96,6 +97,7 @@ class Meta:
             'contract',
             'sku',
             'device',
+            'module',
             'license',
             'end',
             'description',
@@ -110,5 +112,6 @@ class Meta:
             'contract',
             'sku',
             'device',
+            'module',
             'license',
         )

netbox_lifecycle/filtersets/contract.py

@@ -2,7 +2,7 @@
 from django.db.models import Q
 from django.utils.translation import gettext as _
 
-from dcim.models import Manufacturer, Device
+from dcim.models import Manufacturer, Device, Module
 from netbox.filtersets import NetBoxModelFilterSet
 from netbox_lifecycle.models import (
     Vendor,
@@ -127,6 +127,17 @@ class SupportContractAssignmentFilterSet(NetBoxModelFilterSet):
         to_field_name='name',
         label=_('Device (name)'),
     )
+    module_id = django_filters.ModelMultipleChoiceFilter(
+        field_name='module',
+        queryset=Module.objects.all(),
+        label=_('Module (ID)'),
+    )
+    module = django_filters.ModelMultipleChoiceFilter(
+        field_name='module__serial',
+        queryset=Module.objects.all(),
+        to_field_name='serial',
+        label=_('Module (serial)'),
+    )
     license_id = django_filters.ModelMultipleChoiceFilter(
         field_name='license__license',
         queryset=License.objects.all(),
@@ -160,6 +171,8 @@ def search(self, queryset, name, value):
             | Q(contract__vendor__name__icontains=value)
             | Q(sku__sku__icontains=value)
             | Q(device__name__icontains=value)
+            | Q(module__serial__icontains=value)
+            | Q(module__module_type__model__icontains=value)
             | Q(license__device__name__icontains=value)
             | Q(license__license__name__icontains=value)
         )

netbox_lifecycle/forms/filtersets.py

@@ -5,7 +5,7 @@
 from django.forms import DateField
 
 from dcim.choices import DeviceStatusChoices
-from dcim.models import Device, Manufacturer
+from dcim.models import Device, Manufacturer, Module
 from netbox.forms import NetBoxModelFilterSetForm
 from netbox_lifecycle.models import (
     HardwareLifecycle,
@@ -135,7 +135,12 @@ class SupportContractAssignmentFilterForm(NetBoxModelFilterSetForm):
     fieldsets = (
         FieldSet('q', 'filter_id', 'tag'),
         FieldSet(
-            'contract_id', 'device_id', 'license_id', 'device_status', name='Assignment'
+            'contract_id',
+            'device_id',
+            'module_id',
+            'license_id',
+            'device_status',
+            name='Assignment',
         ),
     )
     contract_id = DynamicModelMultipleChoiceField(
@@ -156,6 +161,11 @@ class SupportContractAssignmentFilterForm(NetBoxModelFilterSetForm):
         selector=True,
         label=_('Devices'),
     )
+    module_id = DynamicModelMultipleChoiceField(
+        queryset=Module.objects.all(),
+        required=False,
+        label=_('Module'),
+    )
     device_status = forms.MultipleChoiceField(
         label=_('Status'), choices=DeviceStatusChoices, required=False
     )

netbox_lifecycle/forms/model_forms.py

@@ -1,7 +1,7 @@
 from django import forms
 from django.utils.translation import gettext as _
 
-from dcim.models import DeviceType, ModuleType, Manufacturer, Device
+from dcim.models import DeviceType, ModuleType, Manufacturer, Device, Module
 from netbox.forms import NetBoxModelForm
 from netbox_lifecycle.models import (
     HardwareLifecycle,
@@ -101,19 +101,40 @@ class SupportContractAssignmentForm(NetBoxModelForm):
         selector=True,
         label=_('Device'),
     )
+    module = DynamicModelChoiceField(
+        queryset=Module.objects.all(),
+        required=False,
+        selector=True,
+        label=_('Module'),
+        query_params={'device_id': '$device'},
+    )
     license = DynamicModelChoiceField(
         queryset=LicenseAssignment.objects.all(),
         required=False,
         selector=True,
         label=_('License Assignment'),
     )
 
+    fieldsets = (
+        FieldSet('contract', 'sku', name=_('Contract')),
+        FieldSet(
+            TabbedGroups(
+                FieldSet('device', 'module', name=_('Hardware')),
+                FieldSet('license', name=_('License')),
+            ),
+            name=_('Assignment'),
+        ),
+        FieldSet('end', name=_('Dates')),
+        FieldSet('description', 'comments', 'tags', name=_('Other')),
+    )
+
     class Meta:
         model = SupportContractAssignment
         fields = (
             'contract',
             'sku',
             'device',
+            'module',
             'license',
             'end',
             'description',
@@ -124,37 +145,50 @@ class Meta:
             'end': DatePicker(),
         }
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
     def clean(self):
         super().clean()
 
-        # Handle object assignment
-        selected_objects = [
-            field for field in ('device', 'license') if self.cleaned_data[field]
-        ]
+        has_hardware = self.cleaned_data.get('device') or self.cleaned_data.get(
+            'module'
+        )
+        has_license = self.cleaned_data.get('license')
 
-        if len(selected_objects) == 0:
+        # Must select at least one assignment target
+        if not has_hardware and not has_license:
             raise forms.ValidationError(
-                {
-                    'device': "You must select at least a device or license",
-                    'license': "You must select at least a device or license",
-                }
+                _('Select a device, module, or license assignment')
             )
 
+        # Auto-populate device from module if module selected without device
+        if self.cleaned_data.get('module') and not self.cleaned_data.get('device'):
+            self.cleaned_data['device'] = self.cleaned_data['module'].device
+
+        # Validate device matches module.device
+        if (
+            self.cleaned_data.get('device')
+            and self.cleaned_data.get('module')
+            and self.cleaned_data['device'] != self.cleaned_data['module'].device
+        ):
+            raise forms.ValidationError(
+                {'module': _('Module must belong to the selected device')}
+            )
+
+        # Auto-populate device from license if license selected without device
         if self.cleaned_data.get('license') and not self.cleaned_data.get('device'):
-            self.cleaned_data['device'] = self.cleaned_data.get('license').device
-
-        if self.cleaned_data.get('license') and self.cleaned_data.get('device'):
-            if self.cleaned_data.get('license').device != self.cleaned_data.get(
-                'device'
-            ):
-                raise forms.ValidationError(
-                    {
-                        'device': 'Device assigned to license must match device assignment'
-                    }
-                )
+            self.cleaned_data['device'] = self.cleaned_data['license'].device
+
+        # Validate device matches license.device if both are set
+        if (
+            self.cleaned_data.get('license')
+            and self.cleaned_data.get('device')
+            and self.cleaned_data['license'].device
+            and self.cleaned_data['device'] != self.cleaned_data['license'].device
+        ):
+            raise forms.ValidationError(
+                {'device': _('Device must match the device assigned to the license')}
+            )
+
+        return self.cleaned_data
 
 
 class LicenseForm(NetBoxModelForm):

netbox_lifecycle/graphql/types.py

@@ -66,6 +66,7 @@ class SupportContractAssignmentType(NetBoxObjectType):
     contract: SupportContractType
     sku: SupportSKUType | None
     device: DeviceType | None
+    module: ModuleType | None
     license: LicenseType | None
     end: str | None
 

netbox_lifecycle/migrations/0015_supportcontractassignment_module.py

@@ -0,0 +1,26 @@
+# Generated manually for feature/85-120-module-assignment
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dcim', '0185_gfk_indexes'),
+        ('netbox_lifecycle', '0014_rename_last_contract_date_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='supportcontractassignment',
+            name='module',
+            field=models.ForeignKey(
+                blank=True,
+                null=True,
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name='contracts',
+                to='dcim.module',
+            ),
+        ),
+    ]

netbox_lifecycle/models/contract.py

@@ -124,6 +124,13 @@ class SupportContractAssignment(PrimaryModel):
         blank=True,
         related_name='contracts',
     )
+    module = models.ForeignKey(
+        to='dcim.Module',
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name='contracts',
+    )
     license = models.ForeignKey(
         to='netbox_lifecycle.LicenseAssignment',
         on_delete=models.SET_NULL,
@@ -141,23 +148,29 @@ class SupportContractAssignment(PrimaryModel):
     clone_fields = (
         'contract',
         'sku',
+        'module',
         'end',
     )
     prerequisite_models = (
         'netbox_lifecycle.SupportContract',
         'netbox_lifecycle.SupportSKU',
         'netbox_lifecycle.License',
         'dcim.Device',
+        'dcim.Module',
     )
 
     class Meta:
-        ordering = ['contract', 'device', 'license']
+        ordering = ['contract', 'device', 'module', 'license']
         constraints = ()
 
     def __str__(self):
+        if self.module:
+            return f'{self.module}: {self.contract.contract_id}'
         if self.license and self.device:
             return f'{self.device} ({self.license}): {self.contract.contract_id}'
-        return f'{self.device}: {self.contract.contract_id}'
+        if self.device:
+            return f'{self.device}: {self.contract.contract_id}'
+        return f'{self.contract.contract_id}'
 
     def get_absolute_url(self):
         return reverse(
@@ -176,45 +189,42 @@ def get_device_status_color(self):
         return DeviceStatusChoices.colors.get(self.device.status)
 
     def clean(self):
+        has_hardware = self.device or self.module
+        has_license = self.license
+
+        # Must select something
+        if not has_hardware and not has_license:
+            raise ValidationError(_('Select a device, module, or license assignment'))
+
+        # If both device and module, they must match
+        if self.device and self.module and self.device != self.module.device:
+            raise ValidationError(
+                {'module': _('Module must belong to the selected device')}
+            )
+
+        # If license has a device, it must match the assignment's device
+        if self.license and self.license.device and self.device:
+            if self.device != self.license.device:
+                raise ValidationError(
+                    {
+                        'device': _(
+                            'Device must match the device assigned to the license'
+                        )
+                    }
+                )
+
+        # Uniqueness check: contract + device + module + license + sku must be unique
         if (
-            self.device
-            and self.license
-            and SupportContractAssignment.objects.filter(
+            SupportContractAssignment.objects.filter(
                 contract=self.contract,
                 device=self.device,
+                module=self.module,
                 license=self.license,
                 sku=self.sku,
             )
             .exclude(pk=self.pk)
-            .count()
-            > 0
-        ):
-            raise ValidationError('Device or License must be unique')
-        elif (
-            self.device
-            and not self.license
-            and SupportContractAssignment.objects.filter(
-                contract=self.contract,
-                device=self.device,
-                sku=self.sku,
-                license=self.license,
-            )
-            .exclude(pk=self.pk)
-            .count()
-            > 0
+            .exists()
         ):
-            raise ValidationError('Device must be unique')
-        elif (
-            not self.device
-            and self.license
-            and SupportContractAssignment.objects.filter(
-                contract=self.contract,
-                device=self.device,
-                license=self.license,
-                sku=self.sku,
+            raise ValidationError(
+                _('This assignment combination already exists for this contract')
             )
-            .exclude(pk=self.pk)
-            .count()
-            > 0
-        ):
-            raise ValidationError('License must be unique')