Record-Type Option Data Form with Individual Fields

Author: LuPo

CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 0.7.3 (2026-04-07)
+
+### Added
+- **Record-Type Option Data Form with Individual Fields**
+  - Record-type option definitions (e.g., `record(boolean, ipv4-address)`) now show individual form fields for each position in the record instead of a single Data text field
+  - Boolean record fields render as a select dropdown (True/False)
+  - String and other non-IP fields render as text inputs
+  - IP-type fields within records get IPAM/DNS source selectors — single or multi-select based on `is_array` and position (only the last field in a KEA record can be an array)
+
+- **Record-Type IP Source Linking**
+  - New `record_manual_fields` JSONField on `OptionData` stores non-IP field values separately (e.g., `{"0": "true"}`)
+  - `OptionData.to_kea_dict()` assembles the final data by interleaving manual fields and resolved IPs at correct positions (e.g., `"true, 10.0.0.1, 10.0.0.2"`)
+  - `OptionDefinition` gains `parsed_record_types()` and `record_ip_field_index()` helper methods
+
+### Changed
+- `OptionData.clean()` skips type validation for IP-position fields in record types — IPs come from validated NetBox objects and need no re-checking
+- Record-type options with commas in the data field no longer trigger the "not an array" validation error
+- API `data` field on OptionData now returns resolved data from `to_kea_dict()` instead of raw stored value — shows assembled record fields and resolved IP sources
+
+### Migrations
+- `0005_optiondata_record_manual_fields` — adds `record_manual_fields` JSONField to `OptionData`
+
 ## 0.7.2 (2026-04-01)
 
 ### Added

netbox_dhcp_kea_plugin/__init__.py

@@ -2,7 +2,7 @@
 
 __author__ = """Łukasz Polański"""
 __email__ = "wookasz@gmail.com"
-__version__ = "0.7.2"
+__version__ = "0.7.3"
 
 
 from netbox.plugins import PluginConfig

netbox_dhcp_kea_plugin/api/serializers.py

@@ -194,6 +194,11 @@ class OptionDataSerializer(NetBoxModelSerializer):
     definition = NestedOptionDefinitionSerializer(read_only=True)
     vendor_option_space = NestedVendorOptionSpaceSerializer(read_only=True)
     ip_sources = OptionDataIPSourceSerializer(many=True, read_only=True)
+    data = serializers.SerializerMethodField()
+
+    def get_data(self, obj):
+        """Return resolved data from to_kea_dict() for record/IP-source options."""
+        return obj.to_kea_dict().get("data", obj.data)
 
     class Meta:
         model = OptionData

netbox_dhcp_kea_plugin/forms.py

@@ -595,68 +595,118 @@ def __init__(self, *args, **kwargs):
             }
         )
 
-        # Determine if IP source fields should be shown based on selected definition
-        show_ip_sources = False
+        # Determine form mode based on selected definition
+        # Modes: "simple_ip" (plain ipv4/ipv6), "record" (individual fields per record type), "manual" (text data)
+        self._record_mode = False
+        self._record_types_list = []
+        self._record_ip_index = None
+        mode = "manual"
         is_array = True
         definition_id = get_field_value(self, "definition")
+        defn = None
         if definition_id:
             try:
                 defn = OptionDefinition.objects.get(pk=definition_id)
-                show_ip_sources = defn.option_type == "ipv4-address"
                 is_array = defn.is_array
+                if defn.option_type in OptionDefinition.IP_TYPES:
+                    mode = "simple_ip"
+                elif defn.option_type == "record" and defn.record_types:
+                    mode = "record"
             except OptionDefinition.DoesNotExist:
                 pass
 
-        if not show_ip_sources:
+        if mode == "manual":
             self.fields.pop("ipam_ip_sources", None)
             self.fields.pop("dns_record_sources", None)
-        else:
-            # Hide data field — IP sources replace manual data entry for IP-type options
+        elif mode == "simple_ip":
+            # Hide data field — IP sources replace manual data entry
             self.fields.pop("data", None)
-            # For single-value options, use single-select instead of multi-select
-            if not is_array:
-                self.fields["ipam_ip_sources"] = DynamicModelChoiceField(
-                    queryset=IPAddress.objects.all(),
-                    required=False,
-                    label="IPAM IP Address",
-                    help_text="Select an IP address from NetBox IPAM. Overrides the Data field in KEA config output.",
-                )
-
-            # Add DNS Record source field if netbox-dns integration is enabled
-            if get_plugin_config("netbox_dhcp_kea_plugin", "enable_netbox_dns"):
-                try:
-                    from netbox_dns.models import Record as DNSRecord
-
-                    dns_query_params = {"type": ["A", "AAAA", "CNAME"]}
-                    if is_array:
-                        self.fields["dns_record_sources"] = DynamicModelMultipleChoiceField(
-                            queryset=DNSRecord.objects.all(),
-                            query_params=dns_query_params,
-                            required=False,
-                            label="DNS Records",
-                            help_text="Select DNS A/AAAA or CNAME records. IPs resolved at KEA config generation time.",
-                        )
-                    else:
-                        self.fields["dns_record_sources"] = DynamicModelChoiceField(
-                            queryset=DNSRecord.objects.all(),
-                            query_params=dns_query_params,
-                            required=False,
-                            label="DNS Record",
-                            help_text="Select a DNS A/AAAA or CNAME record. IP resolved at KEA config generation time.",
-                        )
-                except ImportError:
-                    pass
-
-            # Pre-populate IP source fields for existing objects
+            self._add_ip_source_fields(is_array)
             if self.instance.pk:
                 self._populate_ip_source_fields()
+        elif mode == "record":
+            self._record_mode = True
+            self._record_types_list = defn.parsed_record_types()
+            self._record_ip_index = defn.record_ip_field_index()
+            # Hide the plain data field — we build it from individual record fields
+            self.fields.pop("data", None)
+            # Add a field for each position in the record
+            for i, type_name in enumerate(self._record_types_list):
+                if type_name in OptionDefinition.IP_TYPES:
+                    continue  # IP positions get source selectors below
+                if type_name == "boolean":
+                    self.fields[f"record_field_{i}"] = forms.ChoiceField(
+                        choices=[("true", "True"), ("false", "False")],
+                        label=f"Field {i + 1} ({type_name})",
+                        required=False,
+                        help_text=f"Record field {i + 1}: {type_name}",
+                    )
+                else:
+                    self.fields[f"record_field_{i}"] = forms.CharField(
+                        label=f"Field {i + 1} ({type_name})",
+                        required=False,
+                        help_text=f"Record field {i + 1}: {type_name}",
+                    )
+            # Add IP source selectors if the record has an IP-type field
+            if self._record_ip_index is not None:
+                # Only the last field in a record can be an array in KEA
+                ip_is_array = is_array and self._record_ip_index == len(self._record_types_list) - 1
+                self._add_ip_source_fields(ip_is_array)
+            else:
+                self.fields.pop("ipam_ip_sources", None)
+                self.fields.pop("dns_record_sources", None)
+            # Pre-populate for existing objects
+            if self.instance.pk:
+                self._populate_ip_source_fields()
+
+    def _add_ip_source_fields(self, is_array):
+        """Add IPAM and DNS IP source selector fields."""
+        if not is_array:
+            self.fields["ipam_ip_sources"] = DynamicModelChoiceField(
+                queryset=IPAddress.objects.all(),
+                required=False,
+                label="IPAM IP Address",
+                help_text="Select an IP address from NetBox IPAM.",
+            )
+        # (multi-select is already defined as a class field; only override for single)
+
+        if get_plugin_config("netbox_dhcp_kea_plugin", "enable_netbox_dns"):
+            try:
+                from netbox_dns.models import Record as DNSRecord
+
+                dns_query_params = {"type": ["A", "AAAA", "CNAME"]}
+                if is_array:
+                    self.fields["dns_record_sources"] = DynamicModelMultipleChoiceField(
+                        queryset=DNSRecord.objects.all(),
+                        query_params=dns_query_params,
+                        required=False,
+                        label="DNS Records",
+                        help_text="Select DNS A/AAAA or CNAME records. IPs resolved at KEA config generation time.",
+                    )
+                else:
+                    self.fields["dns_record_sources"] = DynamicModelChoiceField(
+                        queryset=DNSRecord.objects.all(),
+                        query_params=dns_query_params,
+                        required=False,
+                        label="DNS Record",
+                        help_text="Select a DNS A/AAAA or CNAME record. IP resolved at KEA config generation time.",
+                    )
+            except ImportError:
+                pass
 
     def _populate_ip_source_fields(self):
         """Set initial values for IP source fields from existing OptionDataIPSource entries."""
         from django.contrib.contenttypes.models import ContentType
 
         from netbox_dhcp_kea_plugin.models import OptionDataIPSource
 
+        # Populate record manual fields from stored JSON
+        if self._record_mode and self.instance.record_manual_fields:
+            for idx_str, value in self.instance.record_manual_fields.items():
+                field_name = f"record_field_{idx_str}"
+                if field_name in self.fields:
+                    self.initial[field_name] = value
+
         sources = OptionDataIPSource.objects.filter(option_data=self.instance).order_by("ordinal")
         if not sources.exists():
             return
@@ -687,18 +737,34 @@ def fieldsets(self):
                 name="Option Selection",
             ),
         ]
-        # Build IP Sources or manual Data fieldset based on available fields
-        ip_source_items = []
-        if "ipam_ip_sources" in self.fields:
-            ip_source_items.append("ipam_ip_sources")
-        if "dns_record_sources" in self.fields:
-            ip_source_items.append("dns_record_sources")
-        if ip_source_items:
-            base.append(
-                FieldSet(*ip_source_items, InlineFields("always_send", "csv_format", label="Flags"), name="IP Sources")
-            )
+        # Build value fieldset based on form mode
+        if self._record_mode:
+            # Record mode: individual fields for each record position + IP source selectors
+            record_items = []
+            for i, type_name in enumerate(self._record_types_list):
+                field_name = f"record_field_{i}"
+                if field_name in self.fields:
+                    record_items.append(field_name)
+            if "ipam_ip_sources" in self.fields:
+                record_items.append("ipam_ip_sources")
+            if "dns_record_sources" in self.fields:
+                record_items.append("dns_record_sources")
+            record_items.append(InlineFields("always_send", "csv_format", label="Flags"))
+            base.append(FieldSet(*record_items, name="Record Fields"))
         else:
-            base.append(FieldSet("data", InlineFields("always_send", "csv_format", label="Flags"), name="Value"))
+            ip_source_items = []
+            if "ipam_ip_sources" in self.fields:
+                ip_source_items.append("ipam_ip_sources")
+            if "dns_record_sources" in self.fields:
+                ip_source_items.append("dns_record_sources")
+            if ip_source_items:
+                base.append(
+                    FieldSet(
+                        *ip_source_items, InlineFields("always_send", "csv_format", label="Flags"), name="IP Sources"
+                    )
+                )
+            else:
+                base.append(FieldSet("data", InlineFields("always_send", "csv_format", label="Flags"), name="Value"))
         base.append(FieldSet("description", "tags", name="Metadata"))
         return tuple(base)
 
@@ -711,6 +777,21 @@ def clean_csv_format(self):
         return csv_format
 
     def save(self, *args, **kwargs):
+        # Collect record manual fields into JSON before saving
+        if self._record_mode:
+            manual_fields = {}
+            for i, type_name in enumerate(self._record_types_list):
+                field_name = f"record_field_{i}"
+                if field_name in self.cleaned_data:
+                    manual_fields[str(i)] = self.cleaned_data[field_name]
+            self.instance.record_manual_fields = manual_fields or None
+            if self._record_ip_index is not None:
+                # Has IP sources — data will be assembled at config generation time
+                self.instance.data = ""
+            else:
+                # No IP sources — assemble data now from manual fields
+                parts = [manual_fields.get(str(i), "") for i in range(len(self._record_types_list))]
+                self.instance.data = ", ".join(parts)
         instance = super().save(*args, **kwargs)
         self._save_ip_sources(instance)
         return instance

netbox_dhcp_kea_plugin/migrations/0005_optiondata_record_manual_fields.py

@@ -0,0 +1,19 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("netbox_dhcp_kea_plugin", "0004_optiondata_ip_source"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="optiondata",
+            name="record_manual_fields",
+            field=models.JSONField(
+                blank=True,
+                null=True,
+                help_text="For record-type options with IP sources: JSON dict mapping field positions to manual values.",
+            ),
+        ),
+    ]

netbox_dhcp_kea_plugin/models.py

@@ -1183,13 +1183,28 @@ def __str__(self):
     def get_absolute_url(self):
         return reverse("plugins:netbox_dhcp_kea_plugin:optiondefinition", args=[self.pk])
 
+    IP_TYPES = {"ipv4-address", "ipv6-address"}
+
     @property
     def space_name(self):
         """Return the effective space name for KEA config"""
         if self.vendor_option_space:
             return self.vendor_option_space.name
         return self.option_space
 
+    def parsed_record_types(self):
+        """Return a list of type strings from the comma-separated record_types field."""
+        if not self.record_types:
+            return []
+        return [t.strip() for t in self.record_types.split(",")]
+
+    def record_ip_field_index(self):
+        """Return the index of the first IP-type field in record_types, or None."""
+        for i, t in enumerate(self.parsed_record_types()):
+            if t in self.IP_TYPES:
+                return i
+        return None
+
     def to_kea_dict(self):
         """Return a dictionary representation for KEA option-def configuration.
 
@@ -1274,6 +1289,11 @@ class OptionData(NetBoxModel):
         help_text="How to deliver this option: standard (direct), Option 43, or VIVSO (Option 125)",
     )
     data = models.TextField(blank=True, default="", help_text="Option value/data")
+    record_manual_fields = models.JSONField(
+        blank=True,
+        null=True,
+        help_text="For record-type options with IP sources: JSON dict mapping field positions to manual values.",
+    )
     always_send = models.BooleanField(
         default=False,
         help_text="Always send this option even if not requested by client",
@@ -1339,10 +1359,22 @@ def clean(self):
                 self.vendor_option_space = self.definition.vendor_option_space
 
         # Type-based validation of data against definition's option_type
-        if self.csv_format and self.data and self.definition:
+        # For record types with IP sources, validate only the manual fields — IP
+        # positions are filled from validated NetBox objects and need no re-checking.
+        if self.record_manual_fields and self.definition and self.definition.option_type == "record":
+            record_types = self.definition.parsed_record_types()
+            ip_index = self.definition.record_ip_field_index()
+            for idx_str, val in self.record_manual_fields.items():
+                i = int(idx_str)
+                if i == ip_index or not val or i >= len(record_types):
+                    continue
+                self._validate_typed_value(val, record_types[i])
+        elif self.csv_format and self.data and self.definition:
             values = [v.strip() for v in self.data.split(",")] if self.definition.is_array else [self.data.strip()]
-            # Single-value options must not contain commas
-            if not self.definition.is_array and "," in self.data:
+            # Single-value options must not contain commas, unless the definition
+            # is a "record" type where commas separate fields within a single value
+            # (e.g., slp-service-scope: "true, FPSLP, Unscoped").
+            if not self.definition.is_array and self.definition.option_type != "record" and "," in self.data:
                 raise ValidationError(
                     {"data": "This option does not accept multiple values (definition is not an array)."}
                 )
@@ -1470,7 +1502,28 @@ def to_kea_dict(self):
 
         # Add data — resolve from IP sources if linked, otherwise use manual entry
         ip_sources = self.ip_sources.order_by("ordinal")
-        if ip_sources.exists():
+
+        if self.record_manual_fields and self.definition and self.definition.option_type == "record":
+            # Record-type with IP sources: assemble from manual fields + resolved IPs
+            record_types = self.definition.parsed_record_types()
+            ip_index = self.definition.record_ip_field_index()
+            parts = []
+            for i, type_name in enumerate(record_types):
+                if i == ip_index:
+                    # Resolve IP sources for this position
+                    resolved = [self._resolve_ip(src.ip_source) for src in ip_sources]
+                    seen = set()
+                    for entry in resolved:
+                        if not entry:
+                            continue
+                        for ip in entry.split(", "):
+                            if ip not in seen:
+                                seen.add(ip)
+                                parts.append(ip)
+                else:
+                    parts.append(self.record_manual_fields.get(str(i), ""))
+            result["data"] = ", ".join(parts)
+        elif ip_sources.exists():
             resolved = [self._resolve_ip(src.ip_source) for src in ip_sources]
             # Flatten (CNAME sources may resolve to multiple comma-separated IPs)
             # and deduplicate while preserving order.