nautobot 2.4.13__py3-none-any.whl → 2.4.15__py3-none-any.whl

nautobot/dcim/views.py

@@ -37,6 +37,17 @@ from nautobot.core.models.querysets import count_related
 from nautobot.core.templatetags import helpers
 from nautobot.core.templatetags.helpers import has_perms
 from nautobot.core.ui import object_detail
+from nautobot.core.ui.breadcrumbs import (
+    BaseBreadcrumbItem,
+    Breadcrumbs,
+    InstanceBreadcrumbItem,
+    ModelBreadcrumbItem,
+)
+from nautobot.core.ui.bulk_buttons import (
+    BulkDeleteButton,
+    BulkEditButton,
+    BulkRenameButton,
+)
 from nautobot.core.ui.choices import SectionChoices
 from nautobot.core.utils.lookup import get_form_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
@@ -55,9 +66,11 @@ from nautobot.core.views.mixins import (
     ObjectPermissionRequiredMixin,
 )
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
+from nautobot.core.views.utils import get_obj_from_context
 from nautobot.core.views.viewsets import NautobotUIViewSet
 from nautobot.dcim.choices import LocationDataToContactActionChoices
 from nautobot.dcim.forms import LocationMigrateDataToContactForm
+from nautobot.dcim.utils import get_all_network_driver_mappings
 from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Team
 from nautobot.extras.tables import DynamicGroupTable
 from nautobot.extras.views import ObjectChangeLogView, ObjectConfigContextView, ObjectDynamicGroupsView
@@ -256,10 +269,11 @@ class LocationTypeUIViewSet(NautobotUIViewSet):
 
 
 class LocationUIViewSet(NautobotUIViewSet):
-    # We aren't accessing tree fields anywhere so this is safe (note that `parent` itself is a normal foreign
-    # key, not a tree field). If we ever do access tree fields, this will perform worse, because django will
+    # We are only accessing the tree fields from the list view, where `with_tree_fields` is called dynamically
+    # depending on whether the hierarchy is shown in the UI (note that `parent` itself is a normal foreign key, not a
+    # tree field). If we ever do access tree fields elsewhere, this will perform worse, because django will
     # automatically issue a second query (similar to behavior for
-    # https://docs.djangoproject.com/en/3.2/ref/models/querysets/#django.db.models.query.QuerySet.only)
+    # https://docs.djangoproject.com/en/3.2/ref/models/querysets/#django.db.models.query.QuerySet.only).
     queryset = Location.objects.without_tree_fields().select_related("location_type", "parent", "tenant")
     filterset_class = filters.LocationFilterSet
     filterset_form_class = forms.LocationFilterForm
@@ -524,11 +538,41 @@ class RackGroupUIViewSet(NautobotUIViewSet):
 #
 
 
-class RackListView(generic.ObjectListView):
-    queryset = Rack.objects.all()
-    filterset = filters.RackFilterSet
-    filterset_form = forms.RackFilterForm
-    table = tables.RackDetailTable
+class RackUIViewSet(NautobotUIViewSet):
+    bulk_update_form_class = forms.RackBulkEditForm
+    filterset_class = filters.RackFilterSet
+    filterset_form_class = forms.RackFilterForm
+    form_class = forms.RackForm
+    serializer_class = serializers.RackSerializer
+    table_class = tables.RackDetailTable
+    queryset = Rack.objects.select_related("location", "tenant__tenant_group", "rack_group", "role")
+
+    def get_extra_context(self, request, instance):
+        context = super().get_extra_context(request, instance)
+
+        if self.action == "retrieve":
+            # Get 0U and child devices located within the rack
+            context["nonracked_devices"] = Device.objects.filter(rack=instance, position__isnull=True).select_related(
+                "device_type__manufacturer"
+            )
+
+            peer_racks = Rack.objects.restrict(request.user, "view").filter(location=instance.location)
+
+            if instance.rack_group:
+                peer_racks = peer_racks.filter(rack_group=instance.rack_group)
+            else:
+                peer_racks = peer_racks.filter(rack_group__isnull=True)
+
+            context["next_rack"] = peer_racks.filter(name__gt=instance.name).order_by("name").first()
+            context["prev_rack"] = peer_racks.filter(name__lt=instance.name).order_by("-name").first()
+
+            context["reservations"] = RackReservation.objects.restrict(request.user, "view").filter(rack=instance)
+            context["power_feeds"] = (
+                PowerFeed.objects.restrict(request.user, "view").filter(rack=instance).select_related("power_panel")
+            )
+            context["device_count"] = Device.objects.restrict(request.user, "view").filter(rack=instance).count()
+
+        return context
 
 
 class RackElevationListView(generic.ObjectListView):
@@ -584,70 +628,6 @@ class RackElevationListView(generic.ObjectListView):
         }
 
 
-class RackView(generic.ObjectView):
-    queryset = Rack.objects.select_related("location", "tenant__tenant_group", "rack_group", "role")
-
-    def get_extra_context(self, request, instance):
-        # Get 0U and child devices located within the rack
-        nonracked_devices = Device.objects.filter(rack=instance, position__isnull=True).select_related(
-            "device_type__manufacturer"
-        )
-
-        peer_racks = Rack.objects.restrict(request.user, "view").filter(location=instance.location)
-
-        if instance.rack_group:
-            peer_racks = peer_racks.filter(rack_group=instance.rack_group)
-        else:
-            peer_racks = peer_racks.filter(rack_group__isnull=True)
-        next_rack = peer_racks.filter(name__gt=instance.name).order_by("name").first()
-        prev_rack = peer_racks.filter(name__lt=instance.name).order_by("-name").first()
-
-        reservations = RackReservation.objects.restrict(request.user, "view").filter(rack=instance)
-        power_feeds = (
-            PowerFeed.objects.restrict(request.user, "view").filter(rack=instance).select_related("power_panel")
-        )
-
-        device_count = Device.objects.restrict(request.user, "view").filter(rack=instance).count()
-
-        return {
-            "device_count": device_count,
-            "reservations": reservations,
-            "power_feeds": power_feeds,
-            "nonracked_devices": nonracked_devices,
-            "next_rack": next_rack,
-            "prev_rack": prev_rack,
-            **super().get_extra_context(request, instance),
-        }
-
-
-class RackEditView(generic.ObjectEditView):
-    queryset = Rack.objects.all()
-    model_form = forms.RackForm
-    template_name = "dcim/rack_edit.html"
-
-
-class RackDeleteView(generic.ObjectDeleteView):
-    queryset = Rack.objects.all()
-
-
-class RackBulkImportView(generic.BulkImportView):  # 3.0 TODO: remove, unused
-    queryset = Rack.objects.all()
-    table = tables.RackTable
-
-
-class RackBulkEditView(generic.BulkEditView):
-    queryset = Rack.objects.all()
-    filterset = filters.RackFilterSet
-    table = tables.RackTable
-    form = forms.RackBulkEditForm
-
-
-class RackBulkDeleteView(generic.BulkDeleteView):
-    queryset = Rack.objects.all()
-    filterset = filters.RackFilterSet
-    table = tables.RackTable
-
-
 #
 # Rack reservations
 #
@@ -758,6 +738,173 @@ class ManufacturerUIViewSet(NautobotUIViewSet):
 #
 # Device types
 #
+
+
+class DeviceTypeFieldsPanel(object_detail.ObjectFieldsPanel):
+    """
+    Custom panel for DeviceType that renders front_image and rear_image
+    as image previews with links, and falls back to normal rendering for other fields.
+    """
+
+    def render_value(self, key, value, context):
+        obj = get_obj_from_context(context, self.context_object_key)
+
+        if key in ["front_image", "rear_image"]:
+            image = getattr(obj, key, None)
+            if image:
+                return format_html(
+                    '<a href="{}" target="_blank"><img src="{}" alt="{}" class="img-responsive"></a>',
+                    image.url,
+                    image.url,
+                    image.name,
+                )
+            return format_html('<span class="text-muted">&mdash;</span>')
+
+        return super().render_value(key, value, context)
+
+
+# --- Bulk Action Button Base Class ---
+def bulk_footer_buttons(form_id: str, model):
+    """Return all bulk action buttons for a given form+model."""
+    return [
+        BulkRenameButton(form_id=form_id, model=model),
+        BulkEditButton(form_id=form_id, model=model),
+        BulkDeleteButton(form_id=form_id, model=model),
+    ]
+
+
+# --- Tab Configuration ---
+TAB_CONFIGS = [
+    (
+        100,
+        "interfaces",
+        "Interfaces",
+        "dcim:devicetype_interfaces",
+        "interface_templates",
+        tables.InterfaceTemplateTable,
+        InterfaceTemplate,
+    ),
+    (
+        200,
+        "frontports",
+        "Front Ports",
+        "dcim:devicetype_frontports",
+        "front_port_templates",
+        tables.FrontPortTemplateTable,
+        FrontPortTemplate,
+    ),
+    (
+        300,
+        "rearports",
+        "Rear Ports",
+        "dcim:devicetype_rearports",
+        "rear_port_templates",
+        tables.RearPortTemplateTable,
+        RearPortTemplate,
+    ),
+    (
+        400,
+        "consoleports",
+        "Console Ports",
+        "dcim:devicetype_consoleports",
+        "console_port_templates",
+        tables.ConsolePortTemplateTable,
+        ConsolePortTemplate,
+    ),
+    (
+        500,
+        "consoleserverports",
+        "Console Server Ports",
+        "dcim:devicetype_consoleserverports",
+        "console_server_port_templates",
+        tables.ConsoleServerPortTemplateTable,
+        ConsoleServerPortTemplate,
+    ),
+    (
+        600,
+        "powerports",
+        "Power Ports",
+        "dcim:devicetype_powerports",
+        "power_port_templates",
+        tables.PowerPortTemplateTable,
+        PowerPortTemplate,
+    ),
+    (
+        700,
+        "poweroutlets",
+        "Power Outlets",
+        "dcim:devicetype_poweroutlets",
+        "power_outlet_templates",
+        tables.PowerOutletTemplateTable,
+        PowerOutletTemplate,
+    ),
+    (
+        800,
+        "devicebays",
+        "Device Bays",
+        "dcim:devicetype_devicebays",
+        "device_bay_templates",
+        tables.DeviceBayTemplateTable,
+        DeviceBayTemplate,
+    ),
+    (
+        900,
+        "modulebays",
+        "Module Bays",
+        "dcim:devicetype_modulebays",
+        "module_bay_templates",
+        tables.ModuleBayTemplateTable,
+        ModuleBayTemplate,
+    ),
+]
+
+
+# --- Add Components Button Config ---
+ADD_COMPONENTS_CONFIG = [
+    (100, "dcim:consoleporttemplate_add", "Console Ports", "mdi-console", ["dcim.add_consoleporttemplate"]),
+    (
+        200,
+        "dcim:consoleserverporttemplate_add",
+        "Console Server Ports",
+        "mdi-console-network-outline",
+        ["dcim.add_consoleserverporttemplate"],
+    ),
+    (300, "dcim:powerporttemplate_add", "Power Ports", "mdi-power-plug-outline", ["dcim.add_powerporttemplate"]),
+    (400, "dcim:poweroutlettemplate_add", "Power Outlets", "mdi-power-socket", ["dcim.add_poweroutlettemplate"]),
+    (500, "dcim:interfacetemplate_add", "Interfaces", "mdi-ethernet", ["dcim.add_interfacetemplate"]),
+    (600, "dcim:frontporttemplate_add", "Front Ports", "mdi-square-rounded-outline", ["dcim.add_frontporttemplate"]),
+    (700, "dcim:rearporttemplate_add", "Rear Ports", "mdi-square-rounded-outline", ["dcim.add_rearporttemplate"]),
+    (800, "dcim:devicebaytemplate_add", "Device Bays", "mdi-circle-outline", ["dcim.add_devicebaytemplate"]),
+    (900, "dcim:modulebaytemplate_add", "Module Bays", "mdi-tray", ["dcim.add_modulebaytemplate"]),
+]
+
+
+def make_bulk_tab(weight, tab_name, label, url_name, related_attr, table_class, model):
+    """Build a bulk-enabled tab."""
+    form_id = f"{tab_name}template_form"
+    return object_detail.DistinctViewTab(
+        weight=weight,
+        tab_id=tab_name,
+        label=label,
+        url_name=url_name,
+        related_object_attribute=related_attr,
+        panels=(
+            object_detail.ObjectsTablePanel(
+                section=SectionChoices.FULL_WIDTH,
+                weight=100,
+                table_title=label,
+                table_class=table_class,
+                table_filter="device_type",
+                tab_id=tab_name,
+                enable_bulk_actions=True,
+                form_id=form_id,
+                footer_buttons=bulk_footer_buttons(form_id=form_id, model=model),
+            ),
+        ),
+    )
+
+
+# --- DeviceType UI ViewSet ---
 class DeviceTypeUIViewSet(NautobotUIViewSet):
     bulk_update_form_class = forms.DeviceTypeBulkEditForm
     filterset_class = filters.DeviceTypeFilterSet
@@ -767,81 +914,147 @@ class DeviceTypeUIViewSet(NautobotUIViewSet):
     table_class = tables.DeviceTypeTable
     queryset = DeviceType.objects.select_related("manufacturer").prefetch_related("software_image_files")
 
-    def get_extra_context(self, request, instance):
-        if self.action != "retrieve":
-            return {}
-        instance_count = Device.objects.restrict(request.user).filter(device_type=instance).count()
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            DeviceTypeFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+            ),
+            object_detail.ObjectsTablePanel(
+                section=SectionChoices.RIGHT_HALF,
+                weight=200,
+                table_class=tables.SoftwareImageFileTable,
+                table_filter="device_types",
+                select_related_fields=["software_version", "status"],
+                exclude_columns=["actions", "tags"],
+                related_field_name="device_types",
+                add_button_route=None,
+            ),
+            object_detail.ObjectsTablePanel(
+                weight=300,
+                section=SectionChoices.FULL_WIDTH,
+                table_class=tables.DeviceTable,
+                table_filter="device_type",
+                related_field_name="device_type",
+                table_title="Device Instances",
+                exclude_columns=["actions", "tags"],
+            ),
+        ),
+        extra_tabs=tuple(make_bulk_tab(*cfg) for cfg in TAB_CONFIGS),
+        extra_buttons=(
+            object_detail.DropdownButton(
+                weight=100,
+                color=ButtonColorChoices.BLUE,
+                label="Add Components",
+                attributes={"id": "device-type-add-components-button"},
+                icon="mdi-plus-thick",
+                required_permissions=["dcim.change_devicetype"],
+                children=tuple(
+                    object_detail.Button(
+                        weight=weight,
+                        link_name=link_name,
+                        label=label,
+                        icon=icon,
+                        required_permissions=perms,
+                        link_includes_pk=False,
+                    )
+                    for weight, link_name, label, icon, perms in ADD_COMPONENTS_CONFIG
+                ),
+            ),
+        ),
+    )
 
-        # Component tables
-        consoleport_table = tables.ConsolePortTemplateTable(
-            ConsolePortTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
-            orderable=False,
-        )
-        consoleserverport_table = tables.ConsoleServerPortTemplateTable(
-            ConsoleServerPortTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
-            orderable=False,
-        )
-        powerport_table = tables.PowerPortTemplateTable(
-            PowerPortTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
-            orderable=False,
-        )
-        poweroutlet_table = tables.PowerOutletTemplateTable(
-            PowerOutletTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
-            orderable=False,
-        )
-        interface_table = tables.InterfaceTemplateTable(
-            list(InterfaceTemplate.objects.restrict(request.user, "view").filter(device_type=instance)),
-            orderable=False,
-        )
-        front_port_table = tables.FrontPortTemplateTable(
-            FrontPortTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
-            orderable=False,
-        )
-        rear_port_table = tables.RearPortTemplateTable(
-            RearPortTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
-            orderable=False,
-        )
-        devicebay_table = tables.DeviceBayTemplateTable(
-            DeviceBayTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
-            orderable=False,
-        )
-        modulebay_table = tables.ModuleBayTemplateTable(
-            ModuleBayTemplate.objects.restrict(request.user, "view").filter(device_type=instance),
-            orderable=False,
-        )
-        if request.user.has_perm("dcim.change_devicetype"):
-            consoleport_table.columns.show("pk")
-            consoleserverport_table.columns.show("pk")
-            powerport_table.columns.show("pk")
-            poweroutlet_table.columns.show("pk")
-            interface_table.columns.show("pk")
-            front_port_table.columns.show("pk")
-            rear_port_table.columns.show("pk")
-            devicebay_table.columns.show("pk")
-            modulebay_table.columns.show("pk")
+    # View actions
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="interfaces",
+        custom_view_base_action="view",
+        custom_view_additional_permissions=["dcim.view_interfacetemplate"],
+    )
+    def interfaces(self, request, *args, **kwargs):
+        return Response({})
 
-        software_image_files_table = tables.SoftwareImageFileTable(
-            instance.software_image_files.restrict(request.user, "view").annotate(
-                device_type_count=count_related(DeviceType, "software_image_files"),
-            ),
-            orderable=False,
-            exclude=["actions", "tags"],
-        )
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="frontports",
+        custom_view_base_action="view",
+        custom_view_additional_permissions=["dcim.view_frontporttemplate"],
+    )
+    def frontports(self, request, *args, **kwargs):
+        return Response({})
 
-        return {
-            "instance_count": instance_count,
-            "consoleport_table": consoleport_table,
-            "consoleserverport_table": consoleserverport_table,
-            "powerport_table": powerport_table,
-            "poweroutlet_table": poweroutlet_table,
-            "interface_table": interface_table,
-            "front_port_table": front_port_table,
-            "rear_port_table": rear_port_table,
-            "devicebay_table": devicebay_table,
-            "modulebay_table": modulebay_table,
-            "software_image_files_table": software_image_files_table,
-            **super().get_extra_context(request, instance),
-        }
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="rearports",
+        custom_view_base_action="view",
+        custom_view_additional_permissions=["dcim.view_rearporttemplate"],
+    )
+    def rearports(self, request, *args, **kwargs):
+        return Response({})
+
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="consoleports",
+        custom_view_base_action="view",
+        custom_view_additional_permissions=["dcim.view_consoleporttemplate"],
+    )
+    def consoleports(self, request, *args, **kwargs):
+        return Response({})
+
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="consoleserverports",
+        custom_view_base_action="view",
+        custom_view_additional_permissions=["dcim.view_consoleserverporttemplate"],
+    )
+    def consoleserverports(self, request, *args, **kwargs):
+        return Response({})
+
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="powerports",
+        custom_view_base_action="view",
+        custom_view_additional_permissions=["dcim.view_powerporttemplate"],
+    )
+    def powerports(self, request, *args, **kwargs):
+        return Response({})
+
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="poweroutlets",
+        custom_view_base_action="view",
+        custom_view_additional_permissions=["dcim.view_poweroutlettemplate"],
+    )
+    def poweroutlets(self, request, *args, **kwargs):
+        return Response({})
+
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="devicebays",
+        custom_view_base_action="view",
+        custom_view_additional_permissions=["dcim.view_devicebaytemplate"],
+    )
+    def devicebays(self, request, *args, **kwargs):
+        return Response({})
+
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="modulebays",
+        custom_view_base_action="view",
+        custom_view_additional_permissions=["dcim.view_modulebaytemplate"],
+    )
+    def modulebays(self, request, *args, **kwargs):
+        return Response({})
 
 
 class DeviceTypeImportView(generic.ObjectImportView):
@@ -1666,6 +1879,8 @@ class PlatformUIViewSet(NautobotUIViewSet):
         context = super().get_extra_context(request, instance)
         if self.action == "retrieve":
             context["network_driver_tool_names"] = instance.fetch_network_driver_mappings()
+        if self.action in ["create", "update"]:
+            context["network_driver_names"] = sorted(get_all_network_driver_mappings().keys())
         return context
 
 
@@ -1674,6 +1889,27 @@ class PlatformUIViewSet(NautobotUIViewSet):
 #
 
 
+class DeviceBreadcrumbsMixin:
+    breadcrumbs = Breadcrumbs(
+        items={
+            "detail": [
+                ModelBreadcrumbItem(model=Device),
+                ModelBreadcrumbItem(
+                    model=Device,
+                    reverse_query_params=lambda c: {"location": c["object"].location.pk},
+                ),
+                InstanceBreadcrumbItem(
+                    instance=lambda c: c["object"].parent_bay.device,
+                    should_render=lambda c: hasattr(c["object"], "parent_bay"),
+                ),
+                BaseBreadcrumbItem(
+                    label=lambda c: c["object"].parent_bay, should_render=lambda c: hasattr(c["object"], "parent_bay")
+                ),
+            ]
+        }
+    )
+
+
 class DeviceListView(generic.ObjectListView):
     queryset = Device.objects.select_related(
         "device_type__manufacturer",  # Needed for __str__() on device_type
@@ -4127,16 +4363,32 @@ class PowerPanelUIViewSet(NautobotUIViewSet):
                     "name",
                     "location",
                     "rack_group",
+                    "panel_type",
+                    "power_path",
+                    "breaker_position_count",
                 ],
             ),
             object_detail.ObjectsTablePanel(
                 section=SectionChoices.FULL_WIDTH,
                 weight=100,
                 table_class=tables.PowerFeedTable,
+                table_filter="destination_panel",
+                table_title="Incoming Feeders",
+                exclude_columns=["destination_panel", "cable", "cable_peer", "rack"],
+                add_button_route=None,
+                paginate=False,
+                show_table_config_button=False,
+            ),
+            object_detail.ObjectsTablePanel(
+                section=SectionChoices.FULL_WIDTH,
+                weight=200,
+                table_class=tables.PowerFeedTable,
                 table_filter="power_panel",
                 table_title="Connected Feeds",
                 exclude_columns=["power_panel"],
                 add_button_route=None,
+                paginate=False,
+                show_table_config_button=False,
             ),
         )
     )
@@ -4188,13 +4440,22 @@ class PowerFeedUIViewSet(NautobotUIViewSet):
                 section=SectionChoices.LEFT_HALF,
                 weight=200,
                 label="Electrical Characteristics",
-                fields=["supply", "voltage", "amperage", "phase", "max_utilization"],
+                fields=["supply", "voltage", "amperage", "phase", "max_utilization", "available_power"],
                 value_transforms={
                     "voltage": [lambda v: f"{v}V" if v is not None else helpers.placeholder(v)],
                     "amperage": [lambda a: f"{a}A" if a is not None else helpers.placeholder(a)],
                     "max_utilization": [lambda p: f"{p}%" if p is not None else helpers.placeholder(p)],
+                    "available_power": [
+                        lambda p: f"{((p or 0) / 1000):.1f}kVA" if p is not None else helpers.placeholder(p)
+                    ],
                 },
             ),
+            object_detail.KeyValueTablePanel(
+                section=SectionChoices.RIGHT_HALF,
+                weight=200,
+                label="Breaker Configuration",
+                context_data_key="breaker_config_data",
+            ),
             object_detail.KeyValueTablePanel(
                 section=SectionChoices.RIGHT_HALF,
                 weight=300,
@@ -4209,15 +4470,24 @@ class PowerFeedUIViewSet(NautobotUIViewSet):
         if not instance or self.action != "retrieve":
             return context
 
+        label, value = self._get_connected_target(instance)
         context["powerfeed_data"] = {
             "Power Panel": instance.power_panel,
             "Rack": instance.rack,
+            "Power Path": instance.get_power_path_display(),
             "Type": self._get_type_html(instance),  # Render Type with HTML label
             "Status": instance.status,
-            "Connected Device": self._get_connected_device_html(instance),
+            label: value,
             "Utilization (Allocated)": self._get_utilization_data(instance),
         }
 
+        context["breaker_config_data"] = {
+            "Breaker Position": instance.breaker_position,
+            "Breaker Pole Count": instance.get_breaker_pole_count_display(),
+            "Occupied Positions": instance.occupied_positions,
+            "Phase Designation": instance.phase_designation,
+        }
+
         context["connection_data"] = self._get_connection_data(request, instance)
         return context
 
@@ -4229,6 +4499,12 @@ class PowerFeedUIViewSet(NautobotUIViewSet):
         type_class = instance.get_type_class()
         return format_html('<span class="label label-{}">{}</span>', type_class, instance.get_type_display())
 
+    def _get_connected_target(self, instance):
+        """Return (label, value) for the connected row."""
+        if getattr(instance, "destination_panel", None):
+            return "Connected Panel", helpers.hyperlinked_object(instance.destination_panel)
+        return "Connected Device", self._get_connected_device_html(instance)
+
     def _get_connected_device_html(self, instance):
         endpoint = getattr(instance, "connected_endpoint", None)
         if endpoint and endpoint.parent:
@@ -4251,6 +4527,12 @@ class PowerFeedUIViewSet(NautobotUIViewSet):
         if not instance:
             return {}
 
+        if instance.destination_panel:
+            return {
+                "Power Panel": instance.destination_panel,
+                "Panel Type": instance.destination_panel.get_panel_type_display(),
+            }
+
         if instance.cable:
             trace_url = reverse("dcim:powerfeed_trace", kwargs={"pk": instance.pk})
             cable_html = format_html(