nautobot 2.4.2__py3-none-any.whl → 2.4.4__py3-none-any.whl

nautobot/ipam/tests/test_api.py

@@ -13,7 +13,15 @@ from rest_framework import status
 from nautobot.core.testing import APITestCase, APIViewTestCases, disable_warnings
 from nautobot.core.testing.api import APITransactionTestCase
 from nautobot.dcim.choices import InterfaceTypeChoices
-from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType, Manufacturer
+from nautobot.dcim.models import (
+    Device,
+    DeviceType,
+    Interface,
+    Location,
+    LocationType,
+    Manufacturer,
+    VirtualDeviceContext,
+)
 from nautobot.extras.models import CustomField, Role, Status
 from nautobot.ipam import choices
 from nautobot.ipam.models import (
@@ -118,6 +126,7 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
     def setUpTestData(cls):
         cls.vrfs = VRF.objects.all()
         cls.devices = Device.objects.all()
+        cls.vdcs = VirtualDeviceContext.objects.all()
         locations = Location.objects.filter(location_type__name="Campus")
         cluster_type = ClusterType.objects.create(name="Test Cluster Type")
         clusters = (
@@ -154,25 +163,42 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
             virtual_machine=cls.test_vm,
             rd="65000:4",
         )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[0],
+            name="VRFDeviceAssignment 1",
+            rd="65000:5",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[1],
+        )
+
+        cls.update_data = {
+            "name": "VRFDeviceAssignment 2",
+            "rd": "65000:7",
+        }
 
         cls.create_data = [
             {
                 "vrf": cls.vrfs[2].pk,
                 "device": cls.devices[4].pk,
-                "virtual_machine": None,
-                "rd": "65000:4",
+                "rd": "65000:7",
             },
             {
                 "vrf": cls.vrfs[3].pk,
-                "device": None,
                 "virtual_machine": cls.test_vm.pk,
-                "rd": "65000:5",
+                "rd": "65000:8",
             },
             {
                 "vrf": cls.vrfs[4].pk,
                 "device": cls.devices[6].pk,
-                "virtual_machine": None,
-                "rd": "65000:6",
+                "name": "VRFDeviceAssignment 3",
+                "rd": "65000:9",
+            },
+            {
+                "vrf": cls.vrfs[4].pk,
+                "virtual_device_context": cls.vdcs[0].pk,
             },
         ]
         cls.bulk_update_data = {
@@ -181,39 +207,66 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
 
     def test_creating_invalid_vrf_device_assignments(self):
         # Add object-level permission
-        duplicate_device_create_data = {
-            "vrf": self.vrfs[0].pk,
-            "device": self.devices[1].pk,
-            "virtual_machine": None,
-            "rd": "65000:6",
-        }
-        duplicate_vm_create_data = {
-            "vrf": self.vrfs[1].pk,
-            "device": None,
-            "virtual_machine": self.test_vm.pk,
-            "rd": "65000:6",
-        }
-        invalid_create_data = {
-            "vrf": self.vrfs[2].pk,
-            "device": self.devices[6].pk,
-            "virtual_machine": self.test_vm.pk,
-            "rd": "65000:6",
-        }
         self.add_permissions("ipam.add_vrfdeviceassignment")
-        response = self.client.post(self._get_list_url(), duplicate_device_create_data, format="json", **self.header)
-        self.assertContains(
-            response, "The fields device, vrf must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
-        )
-        response = self.client.post(self._get_list_url(), duplicate_vm_create_data, format="json", **self.header)
-        self.assertContains(
-            response, "The fields virtual_machine, vrf must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
-        )
-        response = self.client.post(self._get_list_url(), invalid_create_data, format="json", **self.header)
-        self.assertContains(
-            response,
-            "A VRF cannot be associated with both a device and a virtual machine.",
-            status_code=status.HTTP_400_BAD_REQUEST,
-        )
+        duplicate_create_data = [
+            {
+                "vrf": self.vrfs[0].pk,
+                "device": self.devices[1].pk,
+                "rd": "65000:6",
+            },
+            {
+                "vrf": self.vrfs[1].pk,
+                "virtual_machine": self.test_vm.pk,
+                "rd": "65000:6",
+            },
+            {
+                "vrf": self.vrfs[0].pk,
+                "virtual_device_context": self.vdcs[1].pk,
+                "rd": "65000:6",
+            },
+        ]
+        expected_responses = [
+            "The fields device, vrf must make a unique set.",
+            "The fields virtual_machine, vrf must make a unique set.",
+            "The fields virtual_device_context, vrf must make a unique set.",
+        ]
+        for i, data in enumerate(duplicate_create_data):
+            response = self.client.post(self._get_list_url(), data, format="json", **self.header)
+            self.assertContains(response, expected_responses[i], status_code=status.HTTP_400_BAD_REQUEST)
+
+        # Test VRFDeviceAssignment model clean() code paths
+        vrf = VRF.objects.create(name="New VRF ", namespace=Namespace.objects.first())
+        invalid_create_data = [
+            {
+                "vrf": vrf.pk,
+                "device": self.devices[6].pk,
+                "virtual_machine": self.test_vm.pk,
+            },
+            {
+                "vrf": vrf.pk,
+                "device": self.devices[7].pk,
+                "virtual_device_context": self.vdcs[2].pk,
+            },
+            {
+                "vrf": vrf.pk,
+                "virtual_machine": self.test_vm.pk,
+                "virtual_device_context": self.vdcs[3].pk,
+            },
+            {
+                "vrf": vrf.pk,
+                "name": "VRFDeviceAssignment 5",
+                "rd": "65000:6",
+            },
+        ]
+        expected_responses = [
+            "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual machine.",
+            "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual device context.",
+            "A VRFDeviceAssignment entry cannot be associated with both a virtual machine and a virtual device context.",
+            "A VRFDeviceAssignment entry must be associated with a device, a virtual machine, or a virtual device context.",
+        ]
+        for i, data in enumerate(invalid_create_data):
+            response = self.client.post(self._get_list_url(), data, format="json", **self.header)
+            self.assertContains(response, expected_responses[i], status_code=status.HTTP_400_BAD_REQUEST)
 
 
 class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
@@ -221,50 +274,38 @@ class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
 
     @classmethod
     def setUpTestData(cls):
+        cls.namespace = (
+            Namespace.objects.annotate(prefixes_count=Count("prefixes")).filter(prefixes_count__gte=3).first()
+        )
         cls.vrfs = (
-            VRF.objects.annotate(prefixes_count=Count("namespace__prefixes")).filter(prefixes_count__gte=2).distinct()
+            VRF.objects.create(name="TEST VRF 1", namespace=cls.namespace),
+            VRF.objects.create(name="TEST VRF 2", namespace=cls.namespace),
         )
-        cls.prefixes = Prefix.objects.all()
+        cls.prefixes = Prefix.objects.filter(namespace=cls.namespace)
 
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[0],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[0].namespace)[0],
-        )
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[0],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[0].namespace)[1],
-        )
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[1],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[1].namespace)[0],
-        )
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[1],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[1].namespace)[1],
-        )
         cls.create_data = [
             {
-                "vrf": cls.vrfs[2].pk,
-                "prefix": cls.prefixes.filter(namespace=cls.vrfs[2].namespace).exclude(vrfs=cls.vrfs[2])[0].pk,
+                "vrf": cls.vrfs[0].pk,
+                "prefix": cls.prefixes.first().pk,
             },
             {
-                "vrf": cls.vrfs[3].pk,
-                "prefix": cls.prefixes.filter(namespace=cls.vrfs[3].namespace).exclude(vrfs=cls.vrfs[3])[0].pk,
+                "vrf": cls.vrfs[0].pk,
+                "prefix": cls.prefixes.last().pk,
             },
             {
-                "vrf": cls.vrfs[4].pk,
-                "prefix": cls.prefixes.filter(namespace=cls.vrfs[4].namespace).exclude(vrfs=cls.vrfs[4])[0].pk,
+                "vrf": cls.vrfs[1].pk,
+                "prefix": cls.prefixes.first().pk,
             },
         ]
 
     def test_creating_invalid_vrf_prefix_assignments(self):
         duplicate_create_data = {
-            "vrf": self.vrfs[0].pk,
-            "prefix": self.prefixes.filter(namespace=self.vrfs[0].namespace)[0].pk,
+            "vrf": VRFPrefixAssignment.objects.first().vrf.pk,
+            "prefix": VRFPrefixAssignment.objects.first().prefix.pk,
         }
         wrong_namespace_create_data = {
             "vrf": self.vrfs[0].pk,
-            "prefix": self.prefixes.exclude(namespace=self.vrfs[0].namespace)[0].pk,
+            "prefix": Prefix.objects.exclude(namespace=self.namespace)[0].pk,
         }
         missing_field_create_data = {
             "vrf": self.vrfs[0].pk,

nautobot/ipam/tests/test_filters.py

@@ -10,6 +10,7 @@ from nautobot.dcim.models import (
     Location,
     LocationType,
     Manufacturer,
+    VirtualDeviceContext,
 )
 from nautobot.extras.models import Role, Status, Tag
 from nautobot.ipam.choices import PrefixTypeChoices, ServiceProtocolChoices
@@ -24,7 +25,9 @@ from nautobot.ipam.filters import (
     VLANFilterSet,
     VLANGroupFilterSet,
     VLANLocationAssignmentFilterSet,
+    VRFDeviceAssignmentFilterSet,
     VRFFilterSet,
+    VRFPrefixAssignmentFilterSet,
 )
 from nautobot.ipam.models import (
     IPAddress,
@@ -39,6 +42,8 @@ from nautobot.ipam.models import (
     VLANGroup,
     VLANLocationAssignment,
     VRF,
+    VRFDeviceAssignment,
+    VRFPrefixAssignment,
 )
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import (
@@ -66,12 +71,19 @@ class VRFTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterT
     # skip testing "rd" attribute for generic q filter test as it's not trivially modifiable
     exclude_q_filter_predicates = ["rd"]
     generic_filter_tests = (
+        # ("device", "devices__id"),
+        # ("device", "devices__name"),
         ("export_targets", "export_targets__id"),
         ("export_targets", "export_targets__name"),
         ("import_targets", "import_targets__id"),
         ("import_targets", "import_targets__name"),
+        ("prefix", "prefixes__id"),
         ("name",),
+        ("namespace", "namespace__id"),
+        ("namespace", "namespace__name"),
         ("rd",),
+        # ("virtual_machines", "virtual_machines__id"),
+        # ("virtual_machines", "virtual_machines__name"),
     )
 
     @classmethod
@@ -79,6 +91,36 @@ class VRFTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterT
         instance = cls.queryset.first()
         instance.tags.set(Tag.objects.all()[:2])
 
+    def test_prefix_filter_by_string(self):
+        """Test filtering by prefix strings as an alternative to pk."""
+        prefix = self.queryset.filter(prefixes__isnull=False).first().prefixes.first()
+        params = {"prefix": [prefix.prefix]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefixes__network=prefix.network, prefixes__prefix_length=prefix.prefix_length),
+            ordered=False,
+        )
+
+
+class VRFPrefixAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = VRFPrefixAssignment.objects.all()
+    filterset = VRFPrefixAssignmentFilterSet
+    generic_filter_tests = (
+        ("prefix", "prefix__id"),
+        ("vrf", "vrf__id"),
+        ("vrf", "vrf__name"),
+    )
+
+    def test_prefix_filter_by_string(self):
+        """Test filtering by prefix strings as an alternative to pk."""
+        prefix = self.queryset.first().prefix
+        params = {"prefix": [prefix.prefix]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefix__network=prefix.network, prefix__prefix_length=prefix.prefix_length),
+            ordered=False,
+        )
+
 
 class RouteTargetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = RouteTarget.objects.all()
@@ -190,15 +232,32 @@ class PrefixLocationAssignmentTestCase(FilterTestCases.FilterTestCase):
     # )
 
     def test_prefix(self):
-        ipv4_prefix = str(self.queryset.filter(prefix__ip_version=4).first().prefix)
-        ipv6_prefix = str(self.queryset.filter(prefix__ip_version=6).first().prefix)
+        ipv4_prefix = self.queryset.filter(prefix__ip_version=4).first().prefix
+        ipv6_prefix = self.queryset.filter(prefix__ip_version=6).first().prefix
+
+        params = {"prefix": [ipv4_prefix.prefix, ipv6_prefix.pk]}
+
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefix=ipv6_prefix)
+            | self.queryset.filter(
+                prefix__network=ipv4_prefix.network,
+                prefix__prefix_length=ipv4_prefix.prefix_length,
+                prefix__broadcast=ipv4_prefix.broadcast,
+            ),
+            ordered=False,
+        )
 
-        params = {"prefix": [ipv4_prefix, ipv6_prefix]}
-        prefix_queryset = Prefix.objects.net_equals(ipv4_prefix, ipv6_prefix)
+        params = {"prefix": [ipv4_prefix.pk, ipv6_prefix.prefix]}
 
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs,
-            self.queryset.filter(prefix__in=prefix_queryset),
+            self.queryset.filter(prefix=ipv4_prefix)
+            | self.queryset.filter(
+                prefix__network=ipv6_prefix.network,
+                prefix__prefix_length=ipv6_prefix.prefix_length,
+                prefix__broadcast=ipv6_prefix.broadcast,
+            ),
             ordered=False,
         )
 
@@ -289,11 +348,21 @@ class PrefixFilterCustomDataTestCase(TestCase):
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs, self.queryset.filter(parent=parent4)
         )
+        params = {"parent": ["10.0.0.0/16"]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(parent__network="10.0.0.0", parent__prefix_length=16),
+        )
         parent6 = Prefix.objects.get(prefix="2001:db8::/32", namespace=self.namespace)
         params = {"parent": [str(parent6.pk)]}
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs, self.queryset.filter(parent=parent6)
         )
+        params = {"parent": ["2001:db8::/32"]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(parent__network="2001:db8::", parent__prefix_length=32),
+        )
 
     def test_ip_version(self):
         params = {"ip_version": "6"}
@@ -980,6 +1049,77 @@ class IPAddressToInterfaceTestCase(FilterTestCases.FilterTestCase):
                 )
 
 
+class VRFDeviceAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = VRFDeviceAssignment.objects.all()
+    filterset = VRFDeviceAssignmentFilterSet
+    generic_filter_tests = (
+        ["vrf", "vrf__id"],
+        ["vrf", "vrf__name"],
+        ["device", "device__id"],
+        ["device", "device__name"],
+        ["virtual_machine", "virtual_machine__id"],
+        ["virtual_machine", "virtual_machine__name"],
+        ["virtual_device_context", "virtual_device_context__id"],
+        ["virtual_device_context", "virtual_device_context__name"],
+        ["name"],
+        ["rd"],
+    )
+
+    @classmethod
+    def setUpTestData(cls):
+        # Creating VRFDeviceAssignment instances manually until VRFFactory is enhanced to generate VRFDeviceAssignments
+        cls.vrfs = VRF.objects.all()
+        cls.devices = Device.objects.all()
+        cls.vdcs = VirtualDeviceContext.objects.all()
+        locations = Location.objects.filter(location_type__name="Campus")
+        cluster_type = ClusterType.objects.create(name="Test Cluster Type")
+        cluster = Cluster.objects.create(name="Cluster 1", cluster_type=cluster_type, location=locations[0])
+        vm_status = Status.objects.get_for_model(VirtualMachine).first()
+        vm_role = Role.objects.get_for_model(VirtualMachine).first()
+        cls.test_vm_1 = VirtualMachine.objects.create(
+            cluster=cluster,
+            name="VM 1",
+            role=vm_role,
+            status=vm_status,
+        )
+        cls.test_vm_2 = VirtualMachine.objects.create(
+            cluster=cluster,
+            name="VM 2",
+            role=vm_role,
+            status=vm_status,
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            device=cls.devices[0],
+            rd="65000:1",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            device=cls.devices[1],
+            rd="65000:2",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_machine=cls.test_vm_1,
+            rd="65000:3",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[1],
+            virtual_machine=cls.test_vm_2,
+            rd="65000:4",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[0],
+            name="VRFDeviceAssignment 1",
+            rd="65000:5",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[1],
+        )
+
+
 class VLANGroupTestCase(FilterTestCases.FilterTestCase):
     queryset = VLANGroup.objects.all()
     filterset = VLANGroupFilterSet

nautobot/ipam/tests/test_views.py

@@ -2,6 +2,7 @@ import datetime
 import random
 
 from django.contrib.contenttypes.models import ContentType
+from django.db.models import Count
 from django.test import override_settings
 from django.urls import reverse
 from django.utils.html import strip_tags
@@ -13,7 +14,15 @@ from nautobot.core.templatetags.helpers import hyperlinked_object, queryset_to_p
 from nautobot.core.testing import ModelViewTestCase, post_data, ViewTestCases
 from nautobot.core.testing.utils import extract_page_body
 from nautobot.core.utils.lookup import get_route_for_model
-from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType, Manufacturer
+from nautobot.dcim.models import (
+    Device,
+    DeviceType,
+    Interface,
+    Location,
+    LocationType,
+    Manufacturer,
+    VirtualDeviceContext,
+)
 from nautobot.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
 from nautobot.extras.models import (
     CustomField,
@@ -72,8 +81,9 @@ class VRFTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     @classmethod
     def setUpTestData(cls):
         tenants = Tenant.objects.all()[:2]
-        namespace = Prefix.objects.first().namespace
+        namespace = Namespace.objects.annotate(prefix_count=Count("prefixes")).filter(prefix_count__gt=2).first()
         prefixes = Prefix.objects.filter(namespace=namespace)
+        vdcs = VirtualDeviceContext.objects.all()
         vrf_statuses = Status.objects.get_for_model(VRF)
 
         cls.form_data = {
@@ -85,6 +95,7 @@ class VRFTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "prefixes": [prefixes[1].id],
             "tags": [t.pk for t in Tag.objects.get_for_model(VRF)],
             "status": vrf_statuses.first().pk,
+            "virtual_device_contexts": [vdcs[0].id, vdcs[1].id],
         }
 
         cls.bulk_edit_data = {
@@ -94,6 +105,8 @@ class VRFTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "namespace": prefixes[0].namespace.id,
             "add_prefixes": [prefixes[0].id],
             "remove_prefixes": [prefixes[1].id],
+            "add_virtual_device_contexts": [vdcs[2].id, vdcs[3].id],
+            "remove_virtual_device_contexts": [vdcs[0].id],
         }
 
 

nautobot/project-static/bootstrap-filestyle-1.2.3/bootstrap-filestyle.min.js

@@ -0,0 +1,11 @@
+/*
+ * bootstrap-filestyle
+ * doc: http://markusslima.github.io/bootstrap-filestyle/
+ * github: https://github.com/markusslima/bootstrap-filestyle
+ * fork additions: https://github.com/msheiny/bootstrap-filestyle
+ *
+ * Copyright (c) 2017 Markus Vinicius da Silva Lima
+ * Version 1.2.3
+ * Licensed under the MIT license.
+ */
+(function($){"use strict";var nextId=0;var Filestyle=function(element,options){this.options=options;this.$elementFilestyle=[];this.$element=$(element)};Filestyle.prototype={clear:function(){this.$element.val("");this.$elementFilestyle.find(":text").val("");this.$elementFilestyle.find(".badge").remove()},destroy:function(){this.$element.removeAttr("style").removeData("filestyle");this.$elementFilestyle.remove()},disabled:function(value){if(value===true){if(!this.options.disabled){this.$element.attr("disabled","true");this.$elementFilestyle.find("label").attr("disabled","true");this.options.disabled=true}}else if(value===false){if(this.options.disabled){this.$element.removeAttr("disabled");this.$elementFilestyle.find("label").removeAttr("disabled");this.options.disabled=false}}else{return this.options.disabled}},clearButton:function(value){if(value===true){if(!this.options.clearButton){this.options.clearButton=true;if(this.options.input){this.$elementFilestyle.remove();this.constructor();this.pushNameFiles()}}}else if(value===false){if(this.options.clearButton){this.options.clearButton=false;if(this.options.input){this.$elementFilestyle.remove();this.constructor();this.pushNameFiles()}}}else{return this.options.clearButton}},buttonBefore:function(value){if(value===true){if(!this.options.buttonBefore){this.options.buttonBefore=true;if(this.options.input){this.$elementFilestyle.remove();this.constructor();this.pushNameFiles()}}}else if(value===false){if(this.options.buttonBefore){this.options.buttonBefore=false;if(this.options.input){this.$elementFilestyle.remove();this.constructor();this.pushNameFiles()}}}else{return this.options.buttonBefore}},icon:function(value){if(value===true){if(!this.options.icon){this.options.icon=true;this.$elementFilestyle.find("label").prepend(this.htmlIcon())}}else if(value===false){if(this.options.icon){this.options.icon=false;this.$elementFilestyle.find(".icon-span-filestyle").remove()}}else{return this.options.icon}},input:function(value){if(value===true){if(!this.options.input){this.options.input=true;if(this.options.buttonBefore){this.$elementFilestyle.append(this.htmlInput())}else{this.$elementFilestyle.prepend(this.htmlInput())}this.$elementFilestyle.find(".badge").remove();this.pushNameFiles();this.$elementFilestyle.find(".group-span-filestyle").addClass("input-group-btn")}}else if(value===false){if(this.options.input){this.options.input=false;this.$elementFilestyle.find(":text").remove();var files=this.pushNameFiles();if(files.length>0&&this.options.badge){this.$elementFilestyle.find("label").append(' <span class="badge">'+files.length+"</span>")}this.$elementFilestyle.find(".group-span-filestyle").removeClass("input-group-btn")}}else{return this.options.input}},size:function(value){if(value!==undefined){var btn=this.$elementFilestyle.find("label"),input=this.$elementFilestyle.find("input");btn.removeClass("btn-lg btn-sm");input.removeClass("input-lg input-sm");if(value!="nr"){btn.addClass("btn-"+value);input.addClass("input-"+value)}}else{return this.options.size}},placeholder:function(value){if(value!==undefined){this.options.placeholder=value;this.$elementFilestyle.find("input").attr("placeholder",value)}else{return this.options.placeholder}},buttonText:function(value){if(value!==undefined){this.options.buttonText=value;this.$elementFilestyle.find("label .buttonText").html(this.options.buttonText)}else{return this.options.buttonText}},buttonName:function(value){if(value!==undefined){this.options.buttonName=value;this.$elementFilestyle.find("label").attr({class:"btn "+this.options.buttonName})}else{return this.options.buttonName}},iconName:function(value){if(value!==undefined){this.$elementFilestyle.find(".icon-span-filestyle").attr({class:"icon-span-filestyle "+this.options.iconName})}else{return this.options.iconName}},inputText:function(value){if(value!==undefined){this.options.inputText=value;this.$elementFilestyle.find("input").text(this.options.inputText)}else{return this.options.inputText}},htmlIcon:function(){if(this.options.icon){return'<span style="margin-right: 3px;" class="icon-span-filestyle '+this.options.iconName+'"></span> '}else{return""}},htmlInput:function(){if(this.options.input){return'<input type="text" class="form-control '+(this.options.size=="nr"?"":"input-"+this.options.size)+'" placeholder="'+this.options.placeholder+'" '+(this.options.inputText?'value="'+this.options.inputText+'" ':"")+'" disabled> '}else{return""}},pushNameFiles:function(){var content="",files=[];if(this.$element[0].files===undefined){files[0]={name:this.$element[0]&&this.$element[0].value}}else{files=this.$element[0].files}for(var i=0;i<files.length;i++){content+=files[i].name.split("\\").pop()+", "}if(content!==""){this.$elementFilestyle.find(":text").val(content.replace(/\, $/g,""));this.$elementFilestyle.find(".clear-button").removeClass("hidden")}else{this.$elementFilestyle.find(":text").val("");this.$elementFilestyle.find(".clear-button").addClass("hidden")}return files},constructor:function(){var _self=this,html="",id=_self.$element.attr("id"),files=[],btn="",clearBtn="",$label;if(id===""||!id){id="filestyle-"+nextId;_self.$element.attr({id:id});nextId++}btn='<span class="group-span-filestyle '+(_self.options.input?"input-group-btn":"")+'">'+'<label for="'+id+'" class="btn '+_self.options.buttonName+" "+(_self.options.size=="nr"?"":"btn-"+_self.options.size)+'" '+(_self.options.disabled?'disabled="true"':"")+">"+_self.htmlIcon()+'<span class="buttonText">'+_self.options.buttonText+"</span>"+"</label>"+"</span>";clearBtn=_self.options.clearButton?'<span class="input-group-btn"><button class="btn btn-default clear-button'+(_self.options.inputText?"":" hidden")+'" type="button">x</button></span>':"";html=_self.options.buttonBefore?btn+_self.htmlInput()+clearBtn:clearBtn+_self.htmlInput()+btn;_self.$elementFilestyle=$('<div class="bootstrap-filestyle input-group">'+html+"</div>");_self.$elementFilestyle.find(".group-span-filestyle").attr("tabindex","0").keypress(function(e){if(e.keyCode===13||e.charCode===32){_self.$elementFilestyle.find("label").click();return false}});_self.$element.css({position:"absolute",clip:"rect(0px 0px 0px 0px)"}).attr("tabindex","-1").after(_self.$elementFilestyle);if(_self.options.disabled||_self.$element.attr("disabled")){_self.$element.attr("disabled","true")}_self.$element.change(function(){var files=_self.pushNameFiles();if(_self.options.input==false&&_self.options.badge){if(_self.$elementFilestyle.find(".badge").length==0){_self.$elementFilestyle.find("label").append(' <span class="badge">'+files.length+"</span>")}else if(files.length==0){_self.$elementFilestyle.find(".badge").remove()}else{_self.$elementFilestyle.find(".badge").html(files.length)}}else{_self.$elementFilestyle.find(".badge").remove()}});if(window.navigator.userAgent.search(/firefox/i)>-1){_self.$elementFilestyle.find("label").click(function(){_self.$element.click();return false})}if(_self.options.clearButton){var $clearButton=_self.$elementFilestyle.find(".clear-button");$clearButton.on("click",function(e){var $input=_self.$element,input=$input[0];try{$input.val("");if(input.value){input.type="text";input.type="file"}$clearButton.addClass("hidden");$input.trigger("change")}catch(e){}})}}};var old=$.fn.filestyle;$.fn.filestyle=function(option,value){var get="",element=this.each(function(){if($(this).attr("type")==="file"){var $this=$(this),data=$this.data("filestyle"),options=$.extend({},$.fn.filestyle.defaults,option,typeof option==="object"&&option);if(!data){$this.data("filestyle",data=new Filestyle(this,options));data.constructor()}if(typeof option==="string"){get=data[option](value)}}});if(typeof get!==undefined){return get}else{return element}};$.fn.filestyle.defaults={buttonText:"Choose file",iconName:"glyphicon glyphicon-folder-open",buttonName:"btn-default",size:"nr",input:true,inputText:"",badge:true,icon:true,buttonBefore:false,disabled:false,clearButton:true};$.fn.filestyle.noConflict=function(){$.fn.filestyle=old;return this};$(function(){$(".filestyle").each(function(){var $this=$(this),options={input:$this.attr("data-input")!=="false",icon:$this.attr("data-icon")!=="false",buttonBefore:$this.attr("data-buttonBefore")==="true",disabled:$this.attr("data-disabled")==="true",size:$this.attr("data-size"),buttonText:$this.attr("data-buttonText"),buttonName:$this.attr("data-buttonName"),iconName:$this.attr("data-iconName"),badge:$this.attr("data-badge")!=="false",placeholder:$this.attr("data-placeholder")};$this.filestyle(options)})})})(window.jQuery);

nautobot/project-static/css/base.css

@@ -1022,3 +1022,14 @@ a.tile.clickable:visited {
     text-decoration: none;
     background-color: #646464;
 }
+
+/* Monaco Editor container */
+.editor-container {
+    display: flex;  /* Use flexbox for layout */
+    flex-direction: column;
+    flex: 1;  /* Allow container to grow */
+    min-height: 100px;
+    position: relative;  /* Required for Monaco's absolute positioning */
+    overflow: hidden;  /* Let Monaco handle scrolling */
+}
+

nautobot/project-static/css/dark.css

@@ -21,7 +21,8 @@ html[data-theme="dark"] .color-block,                     /* Colored choices, li
 html[data-theme="dark"] .select2-selection__choice,       /* Colored choices, like statuses */
 html[data-theme="dark"] #select2-id_color-results,        /* Colored choices, like statuses */
 html[data-theme="dark"] #select2-id_color-container,      /* Colored choices, like statuses */
-html[data-theme="dark"] .hljs {                           /* highlight.js maintains its own dark theme */
+html[data-theme="dark"] .hljs,                            /* highlight.js maintains its own dark theme */
+html[data-theme="dark"] .editor-container {               /* Monaco editor maintains its own dark theme */
   filter: invert(1) hue-rotate(180deg);
 }
 

nautobot/project-static/docs/apps/index.html

@@ -9181,7 +9181,7 @@
 <tr>
 <td><img alt="Logo" src="../assets/app-icons/icon-NautobotPluginNornir.png" /></td>
 <td><a href="https://docs.nautobot.com/projects/plugin-nornir/en/latest/">Nautobot Plugin Nornir</a></td>
-<td>Provides a small shim layer between <a href="https://github.com/nautobot/nornir-nautobot">nornir-nautobot</a> and other plugins. The primary abilities that the plugin provides are a native Nornir ORM based inventory and a credential manager.</td>
+<td>Provides a small shim layer between <a href="https://github.com/nautobot/nornir-nautobot"><code>nornir-nautobot</code></a> and other plugins. The primary abilities that the plugin provides are a native Nornir ORM based inventory and a credential manager.</td>
 </tr>
 <tr>
 <td><img alt="Logo" src="../assets/app-icons/icon-SSoT.png" /></td>

nautobot/project-static/docs/apps/nautobot-apps.html

@@ -9117,7 +9117,7 @@
 
 <h1 id="nautobot-community-apps">Nautobot Community Apps<a class="headerlink" href="#nautobot-community-apps" title="Permanent link">&para;</a></h1>
 <p>The following is a manually curated list of Apps from the wider Nautobot community, which have some sort of documentation.</p>
-<!-- pyml disable-num-lines 4 no-inline-html -->
+<!-- pyml disable-num-lines 4 no-inline-html,proper-names -->
 <table>
 <thead>
 <tr>

nautobot/project-static/docs/code-reference/nautobot/apps/filters.html

@@ -7487,6 +7487,15 @@
     </span>
   </a>
   
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#nautobot.apps.filters.PrefixFilter" class="md-nav__link">
+    <span class="md-ellipsis">
+      PrefixFilter
+    </span>
+  </a>
+  
 </li>
       
         <li class="md-nav__item">
@@ -9724,6 +9733,15 @@
     </span>
   </a>
   
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#nautobot.apps.filters.PrefixFilter" class="md-nav__link">
+    <span class="md-ellipsis">
+      PrefixFilter
+    </span>
+  </a>
+  
 </li>
       
         <li class="md-nav__item">
@@ -10755,6 +10773,50 @@ are needed.</p>
 
 
 
+  </div>
+
+    </div>
+
+</div>
+
+<div class="doc doc-object doc-class">
+
+
+
+<h2 id="nautobot.apps.filters.PrefixFilter" class="doc doc-heading">
+            <code>nautobot.apps.filters.PrefixFilter</code>
+
+
+<a href="#nautobot.apps.filters.PrefixFilter" class="headerlink" title="Permanent link">&para;</a></h2>
+
+
+    <div class="doc doc-contents ">
+            <p class="doc doc-class-bases">
+              Bases: <code><a class="autorefs autorefs-internal" title="nautobot.core.filters.NaturalKeyOrPKMultipleChoiceFilter" href="#nautobot.apps.filters.NaturalKeyOrPKMultipleChoiceFilter">NaturalKeyOrPKMultipleChoiceFilter</a></code></p>
+
+
+        <p>Filter that supports filtering a foreign key to Prefix by either its PK or by a literal <code>prefix</code> string.</p>
+
+
+
+
+
+
+
+
+
+  <div class="doc doc-children">
+
+
+
+
+
+
+
+
+
+
+
   </div>
 
     </div>