nautobot 2.3.10__py3-none-any.whl → 2.3.11__py3-none-any.whl

nautobot/dcim/tests/integration/test_create_device.py

@@ -0,0 +1,86 @@
+from django.urls import reverse
+
+from nautobot.core.testing.integration import SeleniumTestCase
+
+
+class CreateDeviceTestCase(SeleniumTestCase):
+    """
+    Create a device and all pre-requisite objects through the UI.
+    """
+
+    def test_create_device(self):
+        """
+        This test goes through the process of creating a device in the UI. All pre-requisite objects are created:
+        - Manufacturer
+        - Device Type
+        - LocationType
+        - Location
+        - Role
+        - Device
+
+        """
+        self.user.is_superuser = True
+        self.user.save()
+        self.login(self.user.username, self.password)
+
+        # Manufacturer
+        self.click_navbar_entry("Devices", "Manufacturers")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:manufacturer_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:manufacturer_add"))
+        self.browser.fill("name", "Test Manufacturer 1")
+        self.click_edit_form_create_button()
+
+        # Device Type
+        self.click_navbar_entry("Devices", "Device Types")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:devicetype_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:devicetype_add"))
+        self.fill_select2_field("manufacturer", "Test Manufacturer 1")
+        self.browser.fill("model", "Test Device Type 1")
+        self.click_edit_form_create_button()
+
+        # LocationType
+        self.click_navbar_entry("Organization", "Location Types")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:locationtype_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:locationtype_add"))
+        self.fill_select2_multiselect_field("content_types", "dcim | device")
+        self.browser.fill("name", "Test Location Type 1")
+        self.click_edit_form_create_button()
+
+        # Location
+        self.click_navbar_entry("Organization", "Locations")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:location_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:location_add"))
+        self.fill_select2_field("location_type", "Test Location Type 1")
+        self.fill_select2_field("status", "")  # pick first status
+        self.browser.fill("name", "Test Location 1")
+        self.click_edit_form_create_button()
+
+        # Role
+        self.click_navbar_entry("Organization", "Roles")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("extras:role_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("extras:role_add"))
+        self.browser.fill("name", "Test Role 1")
+        self.fill_select2_multiselect_field("content_types", "dcim | device")
+        self.click_edit_form_create_button()
+
+        # Device
+        self.click_navbar_entry("Devices", "Devices")
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:device_list"))
+        self.click_list_view_add_button()
+        self.assertEqual(self.browser.url, self.live_server_url + reverse("dcim:device_add"))
+        self.browser.fill("name", "Test Device Integration Test 1")
+        self.fill_select2_field("role", "Test Role 1")
+        self.fill_select2_field("device_type", "Test Device Type 1")
+        self.fill_select2_field("location", "Test Location 1")
+        self.fill_select2_field("status", "")  # pick first status
+        self.click_edit_form_create_button()
+
+        # Assert that the device was created
+        self.assertTrue(self.browser.is_text_present("Created device Test Device Integration Test 1", wait_time=5))
+        self.assertTrue(self.browser.is_text_present("Test Location 1", wait_time=5))
+        self.assertTrue(self.browser.is_text_present("Test Device Type 1", wait_time=5))

nautobot/extras/tests/test_relationships.py

@@ -1395,6 +1395,7 @@ class RequiredRelationshipTestMixin:
         # Protected FK to SoftwareVersion prevents deletion
         Controller.objects.all().delete()
         Device.objects.all().update(software_version=None)
+        Device.objects.all().delete()
 
         # Create required relationships:
         device_ct = ContentType.objects.get_for_model(Device)

nautobot/extras/views.py

@@ -2846,6 +2846,7 @@ class StatusBulkDeleteView(generic.BulkDeleteView):
 
     queryset = Status.objects.all()
     table = tables.StatusTable
+    filterset = filters.StatusFilterSet
 
 
 class StatusDeleteView(generic.ObjectDeleteView):

nautobot/ipam/factory.py

@@ -238,6 +238,9 @@ class VLANFactory(PrimaryModelFactory):
                         lambda: Location.objects.filter(location_type__content_types__in=[vlan_ct]), minimum=0
                     )
                 )
+                if self.vlan_group and self.vlan_group.location:
+                    # add the parent of the vlan group location to the vlan locations
+                    self.locations.add(self.vlan_group.location.ancestors(include_self=True)[0])
 
 
 class VLANGetOrCreateFactory(VLANFactory):

nautobot/ipam/filters.py

@@ -90,6 +90,11 @@ class VRFFilterSet(NautobotFilterSet, StatusModelFilterSetMixin, TenancyModelFil
         to_field_name="name",
         label="Device (ID or name)",
     )
+    virtual_machines = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=VirtualMachine.objects.all(),
+        to_field_name="name",
+        label="Virtual Machine (ID or name)",
+    )
     prefix = NaturalKeyOrPKMultipleChoiceFilter(
         field_name="prefixes",
         queryset=Prefix.objects.all(),

nautobot/ipam/forms.py

@@ -752,6 +752,7 @@ class VLANForm(NautobotModelForm, TenancyForm):
     )
     vlan_group = DynamicModelChoiceField(
         queryset=VLANGroup.objects.all(),
+        query_params={"location": "$locations"},
         required=False,
     )
 
@@ -779,6 +780,22 @@ class VLANForm(NautobotModelForm, TenancyForm):
         }
 
     def clean(self):
+        vlan_group = self.cleaned_data["vlan_group"]
+        locations = self.cleaned_data["locations"]
+        # Validate Vlan Group Location is one of the ancestors of the VLAN locations specified.
+        if vlan_group and vlan_group.location and locations:
+            vlan_group_location = vlan_group.location
+            is_vlan_group_valid = False
+            for location in locations:
+                if vlan_group_location in location.ancestors(include_self=True):
+                    is_vlan_group_valid = True
+                    break
+
+            if not is_vlan_group_valid:
+                locations = list(locations.values_list("name", flat=True))
+                raise ValidationError(
+                    {"vlan_group": [f"VLAN Group {vlan_group} is not in locations {locations} or their ancestors."]}
+                )
         # Validation error raised in signal is not properly handled in form clean
         # Hence handling any validationError that might occur.
         try:

nautobot/ipam/models.py

@@ -1296,7 +1296,8 @@ class IPAddressToInterface(BaseModel):
 
     def __str__(self):
         if self.interface:
-            return f"{self.ip_address!s} {self.interface.device.name} {self.interface.name}"
+            parent_name = self.interface.parent.name if self.interface.parent else "No Parent"
+            return f"{self.ip_address!s} {parent_name} {self.interface.name}"
         else:
             return f"{self.ip_address!s} {self.vm_interface.virtual_machine.name} {self.vm_interface.name}"
 

nautobot/ipam/signals.py

@@ -65,9 +65,9 @@ def ip_address_to_interface_pre_delete(instance, raw=False, **kwargs):
     # that is the primary_v{version} of the host machine.
 
     if getattr(instance, "interface"):
-        host = instance.interface.device
+        host = instance.interface.parent
         other_assignments_exist = (
-            IPAddressToInterface.objects.filter(interface__device=host, ip_address=instance.ip_address)
+            IPAddressToInterface.objects.filter(interface__in=host.all_interfaces, ip_address=instance.ip_address)
             .exclude(id=instance.id)
             .exists()
         )

nautobot/ipam/tables.py

@@ -346,7 +346,7 @@ class PrefixTable(StatusTableMixin, RoleTableMixin, BaseTable):
     prefix = tables.TemplateColumn(
         template_code=PREFIX_COPY_LINK, attrs={"td": {"class": "text-nowrap"}}, order_by=("network", "prefix_length")
     )
-    # vrf = tables.TemplateColumn(template_code=VRF_LINK, verbose_name="VRF")
+    vrf_count = LinkedCountColumn(viewname="ipam:vrf_list", url_params={"prefixes": "pk"}, verbose_name="VRFs")
     tenant = TenantColumn()
     namespace = tables.Column(linkify=True)
     vlan = tables.Column(linkify=True, verbose_name="VLAN")
@@ -368,7 +368,7 @@ class PrefixTable(StatusTableMixin, RoleTableMixin, BaseTable):
             "type",
             "status",
             "children",
-            # "vrf",
+            "vrf_count",
             "namespace",
             "tenant",
             "location_count",
@@ -384,7 +384,7 @@ class PrefixTable(StatusTableMixin, RoleTableMixin, BaseTable):
             "prefix",
             "type",
             "status",
-            # "vrf",
+            "vrf_count",
             "namespace",
             "tenant",
             "location_count",

nautobot/ipam/templates/ipam/ipaddress_assign.html

@@ -18,7 +18,7 @@
             {% endif %}
         {% endfor %}
         <div class="row">
-            <div class="col-md-6 col-md-offset-3">
+            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
                 <h3>Assign an IP Address</h3>
                 {% include 'ipam/inc/ipadress_edit_header.html' with active_tab='assign' %}
                 {% if form.non_field_errors %}
@@ -38,7 +38,7 @@
             </div>
         </div>
         <div class="row">
-            <div class="col-md-6 col-md-offset-3 text-right">
+            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1 text-right">
                 <button type="submit" class="btn btn-primary">Search</button>
                 <a href="{{ return_url }}" class="btn btn-default">Cancel</a>
             </div>

nautobot/ipam/tests/test_models.py

@@ -9,7 +9,7 @@ import netaddr
 
 from nautobot.core.testing.models import ModelTestCases
 from nautobot.dcim import choices as dcim_choices
-from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType
+from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType, Module, ModuleBay, ModuleType
 from nautobot.extras.models import Role, Status
 from nautobot.ipam.choices import IPAddressTypeChoices, PrefixTypeChoices, ServiceProtocolChoices
 from nautobot.ipam.models import (
@@ -171,6 +171,118 @@ class IPAddressToInterfaceTest(TestCase):
             IPAddressToInterface.objects.create(vm_interface=None, interface=None, ip_address=ip_addr)
         self.assertIn("Must associate to either an Interface or a VMInterface.", str(cm.exception))
 
+    def test_primary_ip_retained_when_deleted_from_device_or_module_interface(self):
+        """Test primary_ip4 remains set when the same IP is assigned to multiple interfaces and deleted from one."""
+
+        # Create a module bay on the existing device
+        device_module_bay = ModuleBay.objects.create(parent_device=self.test_device, name="Test Bay")
+
+        # Create a module with an interface and add it to the module bay on the device
+        module = Module.objects.create(
+            module_type=ModuleType.objects.first(),
+            status=Status.objects.get_for_model(Module).first(),
+            parent_module_bay=device_module_bay,
+        )
+
+        # Set status for the module interface
+        int_status = Status.objects.get_for_model(Interface).first()
+
+        # Create an interface on the module
+        interface_module = Interface.objects.create(
+            name="eth0_module",
+            module=module,
+            type=dcim_choices.InterfaceTypeChoices.TYPE_1GE_FIXED,
+            status=int_status,
+        )
+
+        # Link the module to the device
+        self.test_device.installed_device = interface_module
+        self.test_device.save()
+
+        # Create IP and assign it to multiple interfaces
+        ip_address = IPAddress.objects.create(address="192.0.2.1/24", namespace=self.namespace, status=self.status)
+        assignment_device_int1 = IPAddressToInterface.objects.create(interface=self.test_int1, ip_address=ip_address)
+        assignment_module_int1 = IPAddressToInterface.objects.create(interface=interface_module, ip_address=ip_address)
+
+        # Set the primary IP on the device
+        self.test_device.primary_ip4 = assignment_device_int1.ip_address
+        self.test_device.save()
+
+        # Verify that the primary IP is set
+        self.assertEqual(self.test_device.primary_ip4, ip_address)
+
+        # Delete the IP assignment from one interface
+        assignment_device_int1.delete()
+
+        # Refresh and check that the primary IP is still assigned
+        self.test_device.refresh_from_db()
+        self.assertEqual(self.test_device.primary_ip4, ip_address)
+
+        # Verify remaining IP assignments on the IP object
+        remaining_assignments = ip_address.interface_assignments.all()
+        self.assertEqual(remaining_assignments.count(), 1)
+        self.assertIn(assignment_module_int1, remaining_assignments)
+
+    def test_primary_ip_retained_when_deleted_from_device_interface_with_nested_module(self):
+        """Test primary_ip4 remains set when the same IP is assigned to a device and nested module interfaces, and deleted from the device interface."""
+
+        # Create a module bay on the existing device
+        device_module_bay = ModuleBay.objects.create(parent_device=self.test_device, name="Primary Module Bay")
+
+        # Create a primary module with an interface and add it to the module bay on the device
+        primary_module = Module.objects.create(
+            module_type=ModuleType.objects.first(),
+            status=Status.objects.get_for_model(Module).first(),
+            parent_module_bay=device_module_bay,
+        )
+
+        # Create a secondary module bay within the primary module for nested module creation
+        nested_module_bay = ModuleBay.objects.create(parent_module=primary_module, name="Nested Module Bay")
+
+        # Create a nested module within the primary module's module bay
+        nested_module = Module.objects.create(
+            module_type=ModuleType.objects.first(),
+            status=Status.objects.get_for_model(Module).first(),
+            parent_module_bay=nested_module_bay,
+        )
+
+        # Set status for the nested module interface
+        int_status = Status.objects.get_for_model(Interface).first()
+
+        # Create an interface on the nested module and assign an IP
+        nested_interface = Interface.objects.create(
+            name="eth0_nested",
+            module=nested_module,
+            type=dcim_choices.InterfaceTypeChoices.TYPE_1GE_FIXED,
+            status=int_status,
+        )
+
+        # Create IP and assign it to both the device and the nested module interface
+        ip_address = IPAddress.objects.create(address="192.0.2.1/24", namespace=self.namespace, status=self.status)
+        assignment_device_int1 = IPAddressToInterface.objects.create(interface=self.test_int1, ip_address=ip_address)
+        assignment_nested_module = IPAddressToInterface.objects.create(
+            interface=nested_interface, ip_address=ip_address
+        )
+
+        # Set the primary IP on the device to the IP on the device interface
+        self.test_device.primary_ip4 = assignment_nested_module.ip_address
+        self.test_device.save()
+
+        # Verify that the primary IP is correctly set
+        self.assertEqual(self.test_device.primary_ip4, ip_address)
+
+        # Delete the IP assignment from the device interface
+        assignment_device_int1.delete()
+
+        # Refresh and check that the primary IP is still assigned to the device
+        self.test_device.refresh_from_db()
+        self.assertEqual(self.test_device.primary_ip4, ip_address)
+
+        # Confirm that the IP is still associated with the nested module interface
+        remaining_assignments = ip_address.interface_assignments.all()
+        self.assertEqual(remaining_assignments.count(), 1)
+        self.assertIn(assignment_nested_module, remaining_assignments)
+
 
 class TestVarbinaryIPField(TestCase):
     """Tests for `nautobot.ipam.fields.VarbinaryIPField`."""

nautobot/ipam/tests/test_views.py

@@ -9,9 +9,10 @@ from django.utils.timezone import make_aware
 from netaddr import IPNetwork
 
 from nautobot.circuits.models import Circuit, Provider
-from nautobot.core.templatetags.helpers import queryset_to_pks
+from nautobot.core.templatetags.helpers import hyperlinked_object, queryset_to_pks
 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.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
 from nautobot.extras.models import (
@@ -178,6 +179,24 @@ class PrefixTestCase(ViewTestCases.PrimaryObjectViewTestCase, ViewTestCases.List
             "remove_vrfs": [vrfs[1].pk],
         }
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
+    def test_list_objects_with_permission(self):
+        """Test rendering of LinkedCountColumn for related fields."""
+        response = super().test_list_objects_with_permission()
+        response_body = extract_page_body(response.content.decode(response.charset))
+
+        locations_list_url = reverse(get_route_for_model(Location, "list"))
+
+        for prefix in self._get_queryset().all():
+            if str(prefix.pk) in response_body:
+                count = prefix.locations.count()
+                if count > 1:
+                    self.assertBodyContains(
+                        response, f'<a href="{locations_list_url}?prefixes={prefix.pk}" class="badge">{count}</a>'
+                    )
+                elif count == 1:
+                    self.assertBodyContains(response, hyperlinked_object(prefix.locations.first()))
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_empty_queryset(self):
         """
@@ -1043,7 +1062,7 @@ class VLANTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     def setUpTestData(cls):
         cls.locations = Location.objects.filter(location_type=LocationType.objects.get(name="Campus"))
 
-        vlangroups = (
+        cls.vlangroups = (
             VLANGroup.objects.create(name="VLAN Group 1", location=cls.locations.first()),
             VLANGroup.objects.create(name="VLAN Group 2", location=cls.locations.last()),
         )
@@ -1053,25 +1072,40 @@ class VLANTestCase(ViewTestCases.PrimaryObjectViewTestCase):
         status = Status.objects.get_for_model(VLAN).first()
 
         cls.form_data = {
-            "vlan_group": vlangroups[1].pk,
+            "vlan_group": cls.vlangroups[0].pk,
             "vid": 999,
             "name": "VLAN999 with an unwieldy long name since we increased the limit to more than 64 characters",
             "tenant": None,
             "status": status.pk,
             "role": roles[1].pk,
-            "locations": list(cls.locations.values_list("pk", flat=True)[:2]),
+            "locations": list(cls.locations.values_list("pk", flat=True)[:1]),
             "description": "A new VLAN",
             "tags": [t.pk for t in Tag.objects.get_for_model(VLAN)],
         }
 
         cls.bulk_edit_data = {
-            "vlan_group": vlangroups[0].pk,
+            "vlan_group": cls.vlangroups[0].pk,
             "tenant": Tenant.objects.first().pk,
             "status": status.pk,
             "role": roles[0].pk,
             "description": "New description",
         }
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_vlan_group_not_belong_to_vlan_locations(self):
+        """Test that a VLAN cannot be assigned to a VLAN Group that is not in the same location as the VLAN."""
+        vlan_group = self.vlangroups[0]
+        form_data = self.form_data.copy()
+        form_data["vlan_group"] = vlan_group.pk
+        form_data["locations"] = [self.locations.last().pk]
+        self.add_permissions("ipam.add_vlan")
+        request = {
+            "path": self._get_url("add"),
+            "data": post_data(form_data),
+        }
+        response = self.client.post(**request)
+        self.assertBodyContains(response, f"vlan_group: VLAN Group {vlan_group} is not in locations")
+
 
 class ServiceTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     model = Service

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

@@ -9444,12 +9444,137 @@ set <code>sort_items=False</code>.</p>
               Bases: <code><autoref identifier="django_tables2.Column" optional hover>Column</autoref></code></p>
 
 
-      <p>Render a count of related objects linked to a filtered URL.</p>
-<p>:param viewname: The view name to use for URL resolution
-:param view_kwargs: Additional kwargs to pass for URL resolution (optional)
-:param url_params: A dict of query parameters to append to the URL (e.g. ?foo=bar) (optional)
-:param reverse_lookup: The reverse lookup parameter to use to derive the count. If not specified, the first key
-    in <code>url_params</code> will be implicitly used as the <code>reverse_lookup</code> value.</p>
+      <p>Render a count of related objects linked to a filtered URL, or if a single related object is present, the object.</p>
+
+
+<p><span class="doc-section-title">Parameters:</span></p>
+    <table>
+      <thead>
+        <tr>
+          <th>Name</th>
+          <th>Type</th>
+          <th>Description</th>
+          <th>Default</th>
+        </tr>
+      </thead>
+      <tbody>
+          <tr class="doc-section-item">
+            <td><code>viewname</code></td>
+            <td>
+                  <code><autoref identifier="str" optional>str</autoref></code>
+            </td>
+            <td>
+              <div class="doc-md-description">
+                <p>The list view name to use for URL resolution, for example <code>"dcim:location_list"</code></p>
+              </div>
+            </td>
+            <td>
+                <em>required</em>
+            </td>
+          </tr>
+          <tr class="doc-section-item">
+            <td><code>url_params</code></td>
+            <td>
+                  <code><autoref identifier="dict" optional>dict</autoref></code>
+            </td>
+            <td>
+              <div class="doc-md-description">
+                <p>Query parameters to apply to filter the list URL (e.g. <code>{"vlans": "pk"}</code> will add
+<code>?vlans=&lt;record.pk&gt;</code> to the linked list URL)</p>
+              </div>
+            </td>
+            <td>
+                  <code>None</code>
+            </td>
+          </tr>
+          <tr class="doc-section-item">
+            <td><code>view_kwargs</code></td>
+            <td>
+                  <code><autoref identifier="dict" optional>dict</autoref></code>
+            </td>
+            <td>
+              <div class="doc-md-description">
+                <p>Additional kwargs to pass to <code>reverse()</code> for list URL resolution. Rarely used.</p>
+              </div>
+            </td>
+            <td>
+                  <code>None</code>
+            </td>
+          </tr>
+          <tr class="doc-section-item">
+            <td><code>lookup</code></td>
+            <td>
+                  <code><autoref identifier="str" optional>str</autoref></code>
+            </td>
+            <td>
+              <div class="doc-md-description">
+                <p>The field name on the base record that can be used to query the related objects.
+If not specified, <code>nautobot.core.utils.lookup.get_related_field_for_models()</code> will be called at render time
+to attempt to intelligently find the appropriate field.
+TODO: this currently does <em>not</em> support nested lookups via <code>__</code>. That may be solvable in the future.</p>
+              </div>
+            </td>
+            <td>
+                  <code>None</code>
+            </td>
+          </tr>
+          <tr class="doc-section-item">
+            <td><code>reverse_lookup</code></td>
+            <td>
+                  <code><autoref identifier="str" optional>str</autoref></code>
+            </td>
+            <td>
+              <div class="doc-md-description">
+                <p>The reverse lookup parameter to use to derive the count.
+If not specified, the first key in <code>url_params</code> will be implicitly used as the <code>reverse_lookup</code> value.</p>
+              </div>
+            </td>
+            <td>
+                  <code>None</code>
+            </td>
+          </tr>
+          <tr class="doc-section-item">
+            <td><code>**kwargs</code></td>
+            <td>
+                  <code><autoref identifier="dict" optional>dict</autoref></code>
+            </td>
+            <td>
+              <div class="doc-md-description">
+                <p>As the parent Column class.</p>
+              </div>
+            </td>
+            <td>
+                  <code>{}</code>
+            </td>
+          </tr>
+      </tbody>
+    </table>
+
+
+<p><span class="doc-section-title">Examples:</span></p>
+    <div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a><span class="k">class</span> <span class="nc">VLANTable</span><span class="p">(</span><span class="o">...</span><span class="p">,</span> <span class="n">BaseTable</span><span class="p">):</span>
+<a id="__codelineno-0-2" name="__codelineno-0-2" href="#__codelineno-0-2"></a>    <span class="o">...</span>
+<a id="__codelineno-0-3" name="__codelineno-0-3" href="#__codelineno-0-3"></a>    <span class="n">location_count</span> <span class="o">=</span> <span class="n">LinkedCountColumn</span><span class="p">(</span>
+<a id="__codelineno-0-4" name="__codelineno-0-4" href="#__codelineno-0-4"></a>        <span class="c1"># Link for N related locations will be reverse(&quot;dcim:location_list&quot;) + &quot;?vlans=&lt;record.pk&gt;&quot;</span>
+<a id="__codelineno-0-5" name="__codelineno-0-5" href="#__codelineno-0-5"></a>        <span class="n">viewname</span><span class="o">=</span><span class="s2">&quot;dcim:location_list&quot;</span><span class="p">,</span>
+<a id="__codelineno-0-6" name="__codelineno-0-6" href="#__codelineno-0-6"></a>        <span class="n">url_params</span><span class="o">=</span><span class="p">{</span><span class="s2">&quot;vlans&quot;</span><span class="p">:</span> <span class="s2">&quot;pk&quot;</span><span class="p">},</span>
+<a id="__codelineno-0-7" name="__codelineno-0-7" href="#__codelineno-0-7"></a>        <span class="n">verbose_name</span><span class="o">=</span><span class="s2">&quot;Locations&quot;</span><span class="p">,</span>
+<a id="__codelineno-0-8" name="__codelineno-0-8" href="#__codelineno-0-8"></a>    <span class="p">)</span>
+</code></pre></div>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-1-1" name="__codelineno-1-1" href="#__codelineno-1-1"></a><span class="k">class</span> <span class="nc">CloudNetworkTable</span><span class="p">(</span><span class="n">BaseTable</span><span class="p">):</span>
+<a id="__codelineno-1-2" name="__codelineno-1-2" href="#__codelineno-1-2"></a>    <span class="o">...</span>
+<a id="__codelineno-1-3" name="__codelineno-1-3" href="#__codelineno-1-3"></a>    <span class="n">circuit_count</span> <span class="o">=</span> <span class="n">LinkedCountColumn</span><span class="p">(</span>
+<a id="__codelineno-1-4" name="__codelineno-1-4" href="#__codelineno-1-4"></a>        <span class="c1"># Link for N related circuits will be reverse(&quot;circuits:circuit_list&quot;) + &quot;?cloud_network=&lt;record.name&gt;&quot;</span>
+<a id="__codelineno-1-5" name="__codelineno-1-5" href="#__codelineno-1-5"></a>        <span class="n">viewname</span><span class="o">=</span><span class="s2">&quot;circuits:circuit_list&quot;</span><span class="p">,</span>
+<a id="__codelineno-1-6" name="__codelineno-1-6" href="#__codelineno-1-6"></a>        <span class="n">url_params</span><span class="o">=</span><span class="p">{</span><span class="s2">&quot;cloud_network&quot;</span><span class="p">:</span> <span class="s2">&quot;name&quot;</span><span class="p">},</span>
+<a id="__codelineno-1-7" name="__codelineno-1-7" href="#__codelineno-1-7"></a>        <span class="c1"># We&#39;d like to do the below but this module isn&#39;t currently smart enough to build the right Prefetch()</span>
+<a id="__codelineno-1-8" name="__codelineno-1-8" href="#__codelineno-1-8"></a>        <span class="c1"># for a nested lookup:</span>
+<a id="__codelineno-1-9" name="__codelineno-1-9" href="#__codelineno-1-9"></a>        <span class="c1"># lookup=&quot;circuit_terminations__circuit&quot;,</span>
+<a id="__codelineno-1-10" name="__codelineno-1-10" href="#__codelineno-1-10"></a>        <span class="c1"># For the count, .annotate(circuit_count=count_related(Circuit, &quot;circuit_terminations__cloud_network&quot;))</span>
+<a id="__codelineno-1-11" name="__codelineno-1-11" href="#__codelineno-1-11"></a>        <span class="n">reverse_lookup</span><span class="o">=</span><span class="s2">&quot;circuit_terminations__cloud_network&quot;</span><span class="p">,</span>
+<a id="__codelineno-1-12" name="__codelineno-1-12" href="#__codelineno-1-12"></a>        <span class="n">verbose_name</span><span class="o">=</span><span class="s2">&quot;Circuits&quot;</span><span class="p">,</span>
+<a id="__codelineno-1-13" name="__codelineno-1-13" href="#__codelineno-1-13"></a>    <span class="p">)</span>
+</code></pre></div>