nautobot 2.4.18__py3-none-any.whl → 2.4.19__py3-none-any.whl

nautobot/core/ui/object_detail.py

@@ -43,9 +43,11 @@ from nautobot.core.utils.lookup import get_filterset_for_model, get_route_for_mo
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.utils import get_obj_from_context
+from nautobot.dcim.models import Rack
 from nautobot.extras.choices import CustomFieldTypeChoices
 from nautobot.extras.tables import AssociatedContactsTable, DynamicGroupTable, ObjectMetadataTable
 from nautobot.tenancy.models import Tenant
+from nautobot.virtualization.models import Cluster
 
 logger = logging.getLogger(__name__)
 
@@ -123,16 +125,24 @@ class ObjectDetailContent:
 class Component:
     """Common base class for renderable components (tabs, panels, etc.)."""
 
-    def __init__(self, *, weight):
+    def __init__(
+        self,
+        *,
+        weight,
+        required_permissions=None,
+    ):
         """Initialize common Component properties.
 
         Args:
             weight (int): A relative weighting of this Component relative to its peers. Typically lower weights will be
                 rendered "first", usually towards the top left of the page.
+            required_permissions (list, optional): Permissions such as `["dcim.add_consoleport"]`.
+                The component will only be rendered if the user has these permissions.
         """
         self.weight = weight
+        self.required_permissions = required_permissions or []
 
-    def should_render(self, context: dict):
+    def should_render(self, context: Context):
         """
         Check whether this component should be rendered at all.
 
@@ -140,9 +150,13 @@ class Component:
         In general most Components may also return an empty string when actually rendered, which is typically also a
         means to specify that they do not need to be rendered, but may be more expensive to derive.
 
+        The default implementation here checks for `self.required_permissions` if any.
+
         Returns:
             (bool): `True` (default) if this component should be rendered.
         """
+        if self.required_permissions:
+            return context["request"].user.has_perms(self.required_permissions)
         return True
 
     def render(self, context: Context):
@@ -178,12 +192,12 @@ class Button(Component):
         link_name=None,
         icon=None,
         template_path="components/button/default.html",
-        required_permissions=None,
         javascript_template_path=None,
         attributes=None,
         size=None,
         link_includes_pk=True,
         context_object_key=None,
+        render_on_tab_id="main",
         **kwargs,
     ):
         """
@@ -199,30 +213,25 @@ class Button(Component):
             context_object_key (str, optional): The key in the render context that will contain the linked object.
             icon (str, optional): Material Design Icons icon, to include on the button, for example `"mdi-plus-bold"`.
             template_path (str): Template to render for this button.
-            required_permissions (list, optional): Permissions such as `["dcim.add_consoleport"]`.
-                The button will only be rendered if the user has these permissions.
             javascript_template_path (str, optional): JavaScript template to render and include with this button.
                 Does not need to include the wrapping `<script>...</script>` tags as those will be added automatically.
             attributes (dict, optional): Additional HTML attributes and their values to attach to the button.
             size (str, optional): The size of the button (e.g. `xs` or `sm`), used to apply a Bootstrap-style sizing.
+            render_on_tab_id (str, optional): The (only) tab that this button should appear on.
         """
         self.label = label
         self.color = color
         self.link_name = link_name
         self.icon = icon
         self.template_path = template_path
-        self.required_permissions = required_permissions or []
         self.javascript_template_path = javascript_template_path
         self.attributes = attributes
         self.size = size
         self.link_includes_pk = link_includes_pk
         self.context_object_key = context_object_key
+        self.render_on_tab_id = render_on_tab_id
         super().__init__(**kwargs)
 
-    def should_render(self, context: Context):
-        """Render if and only if the requesting user has appropriate permissions (if any)."""
-        return context["request"].user.has_perms(self.required_permissions)
-
     def get_link(self, context: Context):
         """
         Get the hyperlink URL (if any) for this button.
@@ -248,6 +257,11 @@ class Button(Component):
             "size": self.size,
         }
 
+    def should_render(self, context: Context):
+        if not super().should_render(context):
+            return False
+        return context.get("active_tab", "main") == self.render_on_tab_id
+
     def render(self, context: Context):
         """Render this button to HTML, possibly including any associated JavaScript."""
         if not self.should_render(context):
@@ -399,9 +413,18 @@ class Tab(Component):
         """
         return self.label
 
+    def should_render_content(self, context: Context):
+        """
+        Only render a main-view Tab if the active request is for the main object view rather than a separate action.
+        """
+        request = context["request"]
+        obj = get_obj_from_context(context)
+        return request.path == obj.get_absolute_url()
+
     def render(self, context: Context):
         """Render the tab's contents (layout and panels) to HTML."""
-        if not self.should_render(context):
+        # Check should_render_content first as it's generally a cheaper calculation than should_render checking perms
+        if not self.should_render_content(context) or not self.should_render(context):
             return ""
 
         with context.update(
@@ -427,6 +450,7 @@ class DistinctViewTab(Tab):
         url_name (str): The name of the URL pattern to link to, which will be reversed to generate the URL.
         label_wrapper_template_path (str, optional): Template path to render the tab label to HTML.
         related_object_attribute (str, optional): The name of the related object attribute to count for the tab label.
+        hide_if_empty (bool, optional): Do not render this tab if the related_object_attribute is an empty queryset.
     """
 
     def __init__(
@@ -435,39 +459,62 @@ class DistinctViewTab(Tab):
         url_name,
         label_wrapper_template_path="components/tab/label_wrapper_distinct_view.html",
         related_object_attribute="",
+        hide_if_empty=False,
         **kwargs,
     ):
         self.url_name = url_name
         self.related_object_attribute = related_object_attribute
+        self.hide_if_empty = hide_if_empty
         super().__init__(label_wrapper_template_path=label_wrapper_template_path, **kwargs)
 
     def get_extra_context(self, context: Context):
         return {"url": reverse(self.url_name, kwargs={"pk": get_obj_from_context(context).pk})}
 
-    def render_label(self, context: Context):
+    def should_render(self, context: Context):
+        if not super().should_render(context):
+            return False
+
+        self.related_object_count = None
         if not self.related_object_attribute:
-            return super().render_label(context)
+            return True
 
         obj = get_obj_from_context(context)
         if not hasattr(obj, self.related_object_attribute):
             logger.warning(
                 f"{obj} does not have a related attribute {self.related_object_attribute} to count for tab label."
             )
-            return super().render_label(context)
+            return True
 
         try:
-            related_obj_count = getattr(obj, self.related_object_attribute).count()
-            return format_html(
-                "{} {}",
-                self.label,
-                render_to_string("utilities/templatetags/badge.html", badge(related_obj_count, True)),
-            )
+            self.related_object_count = getattr(obj, self.related_object_attribute).count()
         except AttributeError:
-            logger.warning(
+            # Not a warning log, as there are cases where this is expected.
+            logger.debug(
                 f"{obj}'s attribute {self.related_object_attribute} is not a related manager to count for tab label."
             )
+
+        if self.hide_if_empty and not self.related_object_count:
+            return False
+        return True
+
+    def should_render_content(self, context: Context):
+        """
+        A DistinctViewTab should only render its content if the view in question is active.
+        """
+        with context.update(self.get_extra_context(context)):
+            request = context["request"]
+            return request.path == context["url"]
+
+    def render_label(self, context: Context):
+        if not self.related_object_attribute or not self.related_object_count:
             return super().render_label(context)
 
+        return format_html(
+            "{} {}",
+            self.label,
+            render_to_string("utilities/templatetags/badge.html", badge(self.related_object_count, True)),
+        )
+
 
 class Panel(Component):
     """Base class for defining an individual display panel within a Layout within a Tab."""
@@ -607,7 +654,7 @@ class DataTablePanel(Panel):
         **kwargs,
     ):
         """
-        Instantiate a DataDictTablePanel.
+        Instantiate a DataTablePanel.
 
         Args:
             context_data_key (str): The key in the render context that stores the data used to populate the table.
@@ -684,6 +731,7 @@ class ObjectsTablePanel(Panel):
         table_class=None,
         table_filter=None,
         table_attribute=None,
+        distinct=False,
         select_related_fields=None,
         prefetch_related_fields=None,
         order_by_fields=None,
@@ -726,6 +774,7 @@ class ObjectsTablePanel(Panel):
             table_attribute (str, optional): The attribute of the detail view instance that contains the queryset to
                 initialize the table class. e.g. `dynamic_groups`.
                 Mutually exclusive with `table_filter`.
+            distinct (bool, optional): If True, apply `.distinct()` to the table queryset.
             select_related_fields (list, optional): list of fields to pass to table queryset's `select_related` method.
             prefetch_related_fields (list, optional): list of fields to pass to table queryset's `prefetch_related`
                 method.
@@ -761,6 +810,7 @@ class ObjectsTablePanel(Panel):
                 table_class,
                 table_filter,
                 table_attribute,
+                distinct,
                 select_related_fields,
                 prefetch_related_fields,
                 order_by_fields,
@@ -769,8 +819,8 @@ class ObjectsTablePanel(Panel):
         ):
             raise ValueError(
                 "context_table_key cannot be combined with any of the args that are used to dynamically construct the "
-                "table (table_class, table_filter, table_attribute, select_related_fields, prefetch_related_fields, "
-                "order_by_fields, hide_hierarchy_ui)."
+                "table (table_class, table_filter, table_attribute, distinct, select_related_fields, "
+                "prefetch_related_fields, order_by_fields, hide_hierarchy_ui)."
             )
         self.context_table_key = context_table_key
         self.table_class = table_class
@@ -782,6 +832,7 @@ class ObjectsTablePanel(Panel):
             raise ValueError("You must provide a `related_field_name` when specifying `table_attribute`")
         self.table_filter = table_filter
         self.table_attribute = table_attribute
+        self.distinct = distinct
         self.select_related_fields = select_related_fields
         self.prefetch_related_fields = prefetch_related_fields
         self.order_by_fields = order_by_fields
@@ -792,7 +843,7 @@ class ObjectsTablePanel(Panel):
         self.include_columns = include_columns
         self.exclude_columns = exclude_columns
         self.add_button_route = add_button_route
-        self.add_permissions = add_permissions
+        self.add_permissions = add_permissions or []
         self.hide_hierarchy_ui = hide_hierarchy_ui
         self.related_field_name = related_field_name
         self.enable_bulk_actions = enable_bulk_actions
@@ -823,21 +874,26 @@ class ObjectsTablePanel(Panel):
         if self.tab_id:
             return_url += f"?tab={self.tab_id}"
 
-        if self.add_button_route == "default":
-            body_content_table_class = self.table_class or context[self.context_table_key].__class__
-            body_content_table_model = body_content_table_class.Meta.model
-            permission_name = get_permission_for_model(body_content_table_model, "add")
-            if request.user.has_perms([permission_name]):
-                try:
-                    add_route = reverse(get_route_for_model(body_content_table_model, "add"))
-                    body_content_table_add_url = f"{add_route}?{related_field_name}={obj.pk}&return_url={return_url}"
-                except NoReverseMatch:
-                    logger.warning("add route for `body_content_table_model` not found")
+        if self.add_button_route is not None:
+            add_permissions = self.add_permissions
+            if not add_permissions:
+                body_content_table_class = self.table_class or context[self.context_table_key].__class__
+                body_content_table_model = body_content_table_class.Meta.model
+                add_permissions = [get_permission_for_model(body_content_table_model, "add")]
 
-        elif self.add_button_route is not None:
-            if request.user.has_perms(self.add_permissions or []):
-                add_route = reverse(self.add_button_route)
-                body_content_table_add_url = f"{add_route}?{related_field_name}={obj.pk}&return_url={return_url}"
+            if self.add_button_route == "default":
+                if request.user.has_perms(add_permissions):
+                    try:
+                        add_route = reverse(get_route_for_model(body_content_table_model, "add"))
+                        body_content_table_add_url = (
+                            f"{add_route}?{related_field_name}={obj.pk}&return_url={return_url}"
+                        )
+                    except NoReverseMatch:
+                        logger.warning("add route for `body_content_table_model` not found")
+            else:
+                if request.user.has_perms(add_permissions):
+                    add_route = reverse(self.add_button_route)
+                    body_content_table_add_url = f"{add_route}?{related_field_name}={obj.pk}&return_url={return_url}"
 
         return body_content_table_add_url
 
@@ -880,7 +936,8 @@ class ObjectsTablePanel(Panel):
                 )
             if self.order_by_fields:
                 body_content_table_queryset = body_content_table_queryset.order_by(*self.order_by_fields)
-            body_content_table_queryset = body_content_table_queryset.distinct()
+            if self.distinct:
+                body_content_table_queryset = body_content_table_queryset.distinct()
             body_content_table = body_content_table_class(
                 body_content_table_queryset, hide_hierarchy_ui=self.hide_hierarchy_ui, user=request.user
             )
@@ -1004,6 +1061,8 @@ class KeyValueTablePanel(Panel):
         super().__init__(body_wrapper_template_path=body_wrapper_template_path, **kwargs)
 
     def should_render(self, context: Context):
+        if not super().should_render(context):
+            return False
         return bool(self.get_data(context))
 
     def get_data(self, context: Context):
@@ -1093,6 +1152,10 @@ class KeyValueTablePanel(Panel):
         elif isinstance(value, models.Model):
             if hasattr(value, "color"):
                 display = hyperlinked_object_with_color(value)
+            elif isinstance(value, Cluster) and value.cluster_group is not None:
+                display = format_html("{} / {}", hyperlinked_object(value.cluster_group), hyperlinked_object(value))
+            elif isinstance(value, Rack) and value.rack_group is not None:
+                display = format_html("{} / {}", hyperlinked_object(value.rack_group), hyperlinked_object(value))
             elif isinstance(value, Tenant) and value.tenant_group is not None:
                 display = format_html("{} / {}", hyperlinked_object(value.tenant_group), hyperlinked_object(value))
             # TODO: render location hierarchy for Location objects
@@ -1317,6 +1380,8 @@ class ObjectFieldsPanel(KeyValueTablePanel):
                 for token in field_name.split(LOOKUP_SEP):
                     try:
                         field_value = getattr(field_value, token)
+                        if field_value is None:
+                            break
                     except ObjectDoesNotExist:
                         field_value = None
                         break
@@ -1610,7 +1675,7 @@ class _ObjectCustomFieldsPanel(GroupedKeyValueTablePanel):
         if not hasattr(obj, "get_custom_field_groupings"):
             return False
         self.custom_field_data = obj.get_custom_field_groupings(advanced_ui=self.advanced_ui)
-        return bool(self.custom_field_data)
+        return bool(self.custom_field_data) and super().should_render(context)
 
     def get_data(self, context: Context):
         """Remap the response from `get_custom_field_groupings()` to a nested dict as expected by the parent class."""
@@ -1686,7 +1751,7 @@ class _ObjectComputedFieldsPanel(GroupedKeyValueTablePanel):
         if not hasattr(obj, "get_computed_fields_grouping"):
             return False
         self.computed_fields_data = obj.get_computed_fields_grouping(advanced_ui=self.advanced_ui)
-        return bool(self.computed_fields_data)
+        return bool(self.computed_fields_data) and super().should_render(context)
 
     def get_data(self, context: Context):
         """Remap `get_computed_fields_grouping()` to the nested dict format expected by the base class."""
@@ -1732,7 +1797,7 @@ class _ObjectRelationshipsPanel(KeyValueTablePanel):
             self.relationships_data["source"]
             or self.relationships_data["destination"]
             or self.relationships_data["peer"]
-        )
+        ) and super().should_render(context)
 
     def get_data(self, context: Context):
         """Remap `get_relationships_with_related_objects()` to the flat dict format expected by the base class."""
@@ -1783,6 +1848,8 @@ class _ObjectTagsPanel(Panel):
         )
 
     def should_render(self, context: Context):
+        if not super().should_render(context):
+            return False
         return hasattr(get_obj_from_context(context), "tags")
 
     def get_extra_context(self, context: Context):
@@ -1814,6 +1881,8 @@ class _ObjectCommentPanel(ObjectTextPanel):
         )
 
     def should_render(self, context: Context):
+        if not super().should_render(context):
+            return False
         return hasattr(get_obj_from_context(context), "comments")
 
 
@@ -1947,6 +2016,8 @@ class _ObjectDetailContactsTab(Tab):
         super().__init__(tab_id=tab_id, label=label, weight=weight, panels=panels, **kwargs)
 
     def should_render(self, context: Context):
+        if not super().should_render(context):
+            return False
         return getattr(get_obj_from_context(context), "is_contact_associable_model", False)
 
     def render_label(self, context: Context):
@@ -1971,6 +2042,7 @@ class _ObjectDetailGroupsTab(Tab):
         label="Dynamic Groups",
         weight=Tab.WEIGHT_GROUPS_TAB,
         panels=None,
+        required_permissions=("extras.view_dynamic_group",),
         **kwargs,
     ):
         if panels is None:
@@ -1984,15 +2056,20 @@ class _ObjectDetailGroupsTab(Tab):
                     related_field_name="member_id",
                 ),
             )
-        super().__init__(tab_id=tab_id, label=label, weight=weight, panels=panels, **kwargs)
+        super().__init__(
+            tab_id=tab_id,
+            label=label,
+            weight=weight,
+            panels=panels,
+            required_permissions=required_permissions,
+            **kwargs,
+        )
 
     def should_render(self, context: Context):
+        if not super().should_render(context):
+            return False
         obj = get_obj_from_context(context)
-        return (
-            getattr(obj, "is_dynamic_group_associable_model", False)
-            and context["request"].user.has_perm("extras.view_dynamicgroup")
-            and obj.dynamic_groups.exists()
-        )
+        return getattr(obj, "is_dynamic_group_associable_model", False) and obj.dynamic_groups.exists()
 
     def render_label(self, context: Context):
         return format_html(
@@ -2015,6 +2092,7 @@ class _ObjectDetailMetadataTab(Tab):
         label="Object Metadata",
         weight=Tab.WEIGHT_METADATA_TAB,
         panels=None,
+        required_permissions=("extras.view_objectmetadata",),
         **kwargs,
     ):
         if panels is None:
@@ -2030,15 +2108,20 @@ class _ObjectDetailMetadataTab(Tab):
                     header_extra_content_template_path=None,
                 ),
             )
-        super().__init__(tab_id=tab_id, label=label, weight=weight, panels=panels, **kwargs)
+        super().__init__(
+            tab_id=tab_id,
+            label=label,
+            weight=weight,
+            panels=panels,
+            required_permissions=required_permissions,
+            **kwargs,
+        )
 
     def should_render(self, context: Context):
+        if not super().should_render(context):
+            return False
         obj = get_obj_from_context(context)
-        return (
-            getattr(obj, "is_metadata_associable_model", False)
-            and context["request"].user.has_perm("extras.view_objectmetadata")
-            and obj.associated_object_metadata.exists()
-        )
+        return getattr(obj, "is_metadata_associable_model", False) and obj.associated_object_metadata.exists()
 
     def render_label(self, context: Context):
         return format_html(

nautobot/core/ui/titles.py

@@ -15,6 +15,7 @@ DEFAULT_TITLES: dict[str, str] = {
     "bulk_rename": "Renaming {{ selected_objects|length }} {{ verbose_name_plural|bettertitle }} on {{ parent_name }}",
     "bulk_update": "Editing {{ objs_count }} {{ verbose_name_plural|bettertitle }}",
     "changelog": "{{ object.display|default:object }} - Change Log",
+    "config_context": "{{ object.display|default:object }} - Config Context",
     "notes": "{{ object.display|default:object }} - Notes",
     "approve": "Approve {{ verbose_name|bettertitle }}?",
     "deny": "Deny {{ verbose_name|bettertitle }}?",

nautobot/core/utils/requests.py

@@ -156,7 +156,7 @@ def normalize_querydict(querydict, form_class=None, filterset=None):
     does not inherently preserve multiple values as lists.
 
     Args:
-        querydict (QueryDict): The QueryDict to be normalized.
+        querydict (QueryDict): The QueryDict or dictionary as produced by `convert_querydict_to_dict` to be normalized.
         form_class (forms.Form, optional): A form class to identify fields that should be treated as
             lists (e.g., `MultipleChoiceField` or `ModelMultipleChoiceField`).
         filterset (django_filters.FilterSet, optional): A FilterSet instance to identify filters that
@@ -171,7 +171,13 @@ def normalize_querydict(querydict, form_class=None, filterset=None):
     result = {}
 
     if querydict:
-        for key, value_list in querydict.lists():
+        # check if true QueryDict or standard dict in format of querydict, e.g. from `convert_querydict_to_dict`
+        if hasattr(querydict, "lists"):
+            items = querydict.lists()
+        else:
+            items = querydict.items()
+
+        for key, value_list in items:
             if len(value_list) > 1:
                 # More than one value in the querydict for this key, so keep it as a list
                 # TODO: we could check here and de-listify value_list if the form_class field is a single-value one?
@@ -198,3 +204,22 @@ def add_nautobot_version_query_param_to_url(url):
     params["version"] = settings.VERSION
     updated_query = urlencode(params, doseq=True)
     return parsed_url._replace(query=updated_query).geturl()
+
+
+def convert_querydict_to_dict(request_querydict):
+    """
+    Convert QueryDict to standard json serializable dictionary.
+
+    This is useful when you want to serialize a QueryDict to JSON format such as
+    when sending to a Job form or sending it over an API. This is not the same as
+    `normalize_querydict` which preserves single values as singletons and multi-values
+    as lists. This function preserves all values as lists.
+
+    Args:
+        request_querydict (QueryDict): QueryDict to convert.
+
+    Examples:
+        >>> convert_querydict_to_dict(QueryDict('foo=1&bar=2&bar=3&baz='))
+        >>> {'foo': ['1'], 'bar': ['2', '3'], 'baz': ['']}
+    """
+    return {key: value for key, value in request_querydict.lists()}  # pylint: disable=unnecessary-comprehension