refactor: wire YAML export into NetBox's built-in Export dropdown

Replace the standalone InterfaceNameRuleYAMLExportView with NetBox's
native export mechanism:
- Add to_yaml() to InterfaceNameRule model so NetBox offers YAML in
  the Export dropdown
- Override export_yaml() on the list view for deterministic pk-ordered
  output with empty-field stripping
- Remove standalone /rules/export/yaml/ URL and custom template buttons
- Rewrite tests to use the list view's ?export= parameter

Author: marcinpsk

netbox_interface_name_rules/models.py

@@ -315,3 +315,13 @@ def to_csv(self):
             self.enabled,
             self.applies_to_device_interfaces,
         )
+
+    def to_yaml(self):
+        """Return a YAML document for this rule (used by NetBox's built-in Export)."""
+        import yaml
+
+        entry = {}
+        for header, value in zip(self.csv_headers, self.to_csv()):
+            if (value != "" and value is not None) or header in {"name_template"}:
+                entry[header] = value
+        return yaml.dump([entry], default_flow_style=False, allow_unicode=True, sort_keys=False)

netbox_interface_name_rules/templates/netbox_interface_name_rules/interfacenamerule_list.html

@@ -145,21 +145,3 @@ <h6 class="mt-3">Examples</h6>
     </script>
     {{ block.super }}
 {% endblock %}
-
-{% block extra_controls %}
-    <a href="{% url 'plugins:netbox_interface_name_rules:interfacenamerule_export_yaml' %}"
-       class="btn btn-outline-secondary btn-sm"
-       title="Export all rules as YAML">
-        <i class="mdi mdi-download"></i> Export YAML
-    </a>
-{% endblock %}
-
-{% block bulk_buttons %}
-    {{ block.super }}
-    <button type="submit"
-            formaction="{% url 'plugins:netbox_interface_name_rules:interfacenamerule_export_yaml' %}"
-            class="btn btn-outline-secondary btn-sm"
-            title="Export selected rules as YAML">
-        <i class="mdi mdi-download"></i> Export Selected YAML
-    </button>
-{% endblock %}

netbox_interface_name_rules/tests/test_views.py

@@ -790,47 +790,41 @@ def test_csv_round_trip_creates_rule(self):
 
 
 # ---------------------------------------------------------------------------
-# YAMLExportViewTest — new YAML export view
+# YAMLExportTest — YAML export via NetBox's built-in Export dropdown
 # ---------------------------------------------------------------------------
 
 
-class YAMLExportViewTest(ViewTestBase):
-    """Tests for the YAML export view at GET/POST /rules/export/yaml/."""
+class YAMLExportTest(ViewTestBase):
+    """Tests for YAML export via the list view's ?export query parameter."""
 
     @classmethod
     def setUpTestData(cls):
         super().setUpTestData()
-        cls.YAML_URL = reverse("plugins:netbox_interface_name_rules:interfacenamerule_export_yaml")
+        cls.LIST_URL = reverse("plugins:netbox_interface_name_rules:interfacenamerule_list")
 
     def test_yaml_export_unauthenticated_responds(self):
-        """Unauthenticated GET must not serve content to anonymous users.
-
-        setUp() logs in the superuser, so we explicitly logout first to exercise
-        anonymous access.  When LOGIN_REQUIRED=True the mixin redirects (302);
-        when False the view's explicit has_perm check raises PermissionDenied
-        (403).  200 is never valid because AnonymousUser lacks the permission.
-        """
+        """Unauthenticated export must not serve content to anonymous users."""
         self.client.logout()
-        response = self.client.get(self.YAML_URL)
+        response = self.client.get(self.LIST_URL, {"export": ""})
         self.assertIn(response.status_code, [301, 302, 403])
 
     def test_yaml_export_all_returns_200(self):
-        """Authenticated GET /rules/export/yaml/ must return 200."""
+        """Authenticated GET ?export= must return 200."""
         self.client.force_login(self.superuser)
-        response = self.client.get(self.YAML_URL)
+        response = self.client.get(self.LIST_URL, {"export": ""})
         self.assertEqual(response.status_code, 200)
 
     def test_yaml_export_content_type(self):
         """Response Content-Type must contain 'yaml'."""
         self.client.force_login(self.superuser)
-        response = self.client.get(self.YAML_URL)
+        response = self.client.get(self.LIST_URL, {"export": ""})
         self.assertEqual(response.status_code, 200)
         self.assertIn("yaml", response["Content-Type"].lower())
 
     def test_yaml_export_content_disposition(self):
         """Response must include a Content-Disposition attachment header."""
         self.client.force_login(self.superuser)
-        response = self.client.get(self.YAML_URL)
+        response = self.client.get(self.LIST_URL, {"export": ""})
         self.assertEqual(response.status_code, 200)
         self.assertIn("attachment", response.get("Content-Disposition", "").lower())
 
@@ -839,33 +833,18 @@ def test_yaml_export_all_contains_rules(self):
         import yaml
 
         self.client.force_login(self.superuser)
-        response = self.client.get(self.YAML_URL)
+        response = self.client.get(self.LIST_URL, {"export": ""})
         self.assertEqual(response.status_code, 200)
         data = yaml.safe_load(response.content)
         self.assertIsInstance(data, list)
         self.assertEqual(len(data), InterfaceNameRule.objects.count())
 
-    def test_yaml_export_selected_rules_via_post(self):
-        """POST with NetBox bulk-select pk inputs must export only the selected rules."""
-        import yaml
-
-        self.client.force_login(self.superuser)
-        response = self.client.post(
-            self.YAML_URL,
-            {"pk": [self.rule.pk]},
-        )
-        self.assertEqual(response.status_code, 200)
-        data = yaml.safe_load(response.content)
-        self.assertIsInstance(data, list)
-        self.assertEqual(len(data), 1)
-        self.assertEqual(data[0]["name_template"], self.rule.name_template)
-
     def test_yaml_export_structure(self):
         """Each exported YAML entry must contain key fields."""
         import yaml
 
         self.client.force_login(self.superuser)
-        response = self.client.get(self.YAML_URL)
+        response = self.client.get(self.LIST_URL, {"export": ""})
         self.assertEqual(response.status_code, 200)
         rules = yaml.safe_load(response.content)
         self.assertIsInstance(rules, list)

netbox_interface_name_rules/urls.py

@@ -12,7 +12,6 @@
     path("rules/add/", views.InterfaceNameRuleCreateView.as_view(), name="interfacenamerule_add"),
     path("rules/import/", views.InterfaceNameRuleBulkImportView.as_view(), name="interfacenamerule_bulk_import"),
     path("rules/bulk_delete/", views.InterfaceNameRuleBulkDeleteView.as_view(), name="interfacenamerule_bulk_delete"),
-    path("rules/export/yaml/", views.InterfaceNameRuleYAMLExportView.as_view(), name="interfacenamerule_export_yaml"),
     # Rule tester (Build Rule)
     path("rules/test/", views.RuleTestView.as_view(), name="interfacenamerule_test"),
     # Apply rules to existing interfaces

netbox_interface_name_rules/views.py

@@ -8,7 +8,7 @@
 from django.conf import settings
 from django.contrib import messages
 from django.core.exceptions import PermissionDenied
-from django.http import HttpResponse, JsonResponse
+from django.http import JsonResponse
 from django.shortcuts import redirect, render
 from django.urls import reverse
 from django.utils.http import url_has_allowed_host_and_scheme
@@ -54,6 +54,19 @@ class InterfaceNameRuleListView(generic.ObjectListView):
     filterset_form = InterfaceNameRuleFilterForm
     template_name = "netbox_interface_name_rules/interfacenamerule_list.html"
 
+    def export_yaml(self):
+        """Export all rules as a single YAML list (overrides NetBox's per-object concatenation)."""
+        data = []
+        for rule in self.queryset.order_by("pk").select_related(
+            "module_type", "parent_module_type", "device_type", "platform"
+        ):
+            entry = {}
+            for header, value in zip(InterfaceNameRule.csv_headers, rule.to_csv()):
+                if (value != "" and value is not None) or header in {"name_template"}:
+                    entry[header] = value
+            data.append(entry)
+        return yaml.dump(data, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
 
 class InterfaceNameRuleCreateView(generic.ObjectEditView):
     """Create view for InterfaceNameRule."""
@@ -117,52 +130,6 @@ def get(self, request, **kwargs):
         return redirect(f"{url}?{params.urlencode()}")
 
 
-class InterfaceNameRuleYAMLExportView(BaseMultiObjectView):
-    """Export selected or all rules as a YAML file importable via BulkImportView."""
-
-    queryset = InterfaceNameRule.objects.all()
-
-    def get_required_permission(self):
-        """Return the permission required to export rules."""
-        return "netbox_interface_name_rules.view_interfacenamerule"
-
-    def _rules_to_yaml_data(self, queryset):
-        """Return a list of dicts (one per rule) using import-form field names."""
-        records = []
-        for rule in queryset.select_related("module_type", "parent_module_type", "device_type", "platform"):
-            entry = {}
-            for header, value in zip(InterfaceNameRule.csv_headers, rule.to_csv()):
-                if (value != "" and value is not None) or header in {"name_template"}:
-                    entry[header] = value
-            records.append(entry)
-        return records
-
-    def _build_response(self, queryset):
-        data = self._rules_to_yaml_data(queryset)
-        content = yaml.dump(data, default_flow_style=False, allow_unicode=True, sort_keys=False)
-        response = HttpResponse(content, content_type="application/yaml; charset=utf-8")
-        response["Content-Disposition"] = 'attachment; filename="interface_name_rules.yaml"'
-        return response
-
-    def get(self, request):
-        """Export all rules as YAML."""
-        return self._build_response(self.queryset.order_by("pk"))
-
-    def post(self, request):
-        """Export selected rules as YAML using NetBox's bulk-select form (pk inputs).
-
-        The parent object_list.html wraps the table in a POST form; selected rows
-        post their PKs as repeated ``pk`` inputs.  Falls back to all rules when
-        nothing is selected.
-        """
-        pk_list = [int(v) for v in request.POST.getlist("pk") if v.isdigit()]
-        if pk_list:
-            queryset = self.queryset.filter(pk__in=pk_list).order_by("pk")
-        else:
-            queryset = self.queryset.order_by("pk")
-        return self._build_response(queryset)
-
-
 class RuleTestView(BaseMultiObjectView):
     """Live-preview a name template with user-supplied variable values and optional DB lookup."""