nautobot 2.2.9__py3-none-any.whl → 2.3.0__py3-none-any.whl

nautobot/core/views/paginator.py

@@ -41,13 +41,14 @@ class EnhancedPage(Page):
         return page_list
 
 
-def get_paginate_count(request):
+def get_paginate_count(request, saved_view=None):
     """
     Determine the length of a page, using the following in order:
 
         1. per_page URL query parameter
-        2. Saved user preference
-        3. PAGINATE_COUNT global setting.
+        2. Saved view config
+        3. Saved user preference
+        4. PAGINATE_COUNT global setting.
     """
     if "per_page" in request.GET:
         try:
@@ -58,6 +59,11 @@ def get_paginate_count(request):
         except ValueError:
             pass
 
+    if saved_view is not None:
+        per_page = saved_view.config.get("pagination_count", None)
+        if per_page:
+            return per_page
+
     if request.user.is_authenticated:
         return request.user.get_config("pagination.per_page", config.get_settings_or_config("PAGINATE_COUNT"))
     return config.get_settings_or_config("PAGINATE_COUNT")

nautobot/core/views/renderers.py

@@ -2,7 +2,9 @@ import logging
 
 from django.contrib import messages
 from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import ObjectDoesNotExist
 from django.db.models import Q
+from django.template import engines, loader
 from django_tables2 import RequestConfig
 from rest_framework import renderers
 
@@ -14,17 +16,20 @@ from nautobot.core.forms import (
 from nautobot.core.forms.forms import DynamicFilterFormSet
 from nautobot.core.templatetags.helpers import bettertitle, validated_viewname
 from nautobot.core.utils.config import get_settings_or_config
-from nautobot.core.utils.lookup import get_created_and_last_updated_usernames_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.utils.requests import (
     convert_querydict_to_factory_formset_acceptable_querydict,
     normalize_querydict,
 )
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
-from nautobot.core.views.utils import check_filter_for_display, get_csv_form_fields_from_serializer_class
+from nautobot.core.views.utils import (
+    check_filter_for_display,
+    common_detail_view_context,
+    get_csv_form_fields_from_serializer_class,
+    view_changes_not_saved,
+)
+from nautobot.extras.models import SavedView
 from nautobot.extras.models.change_logging import ObjectChange
-from nautobot.extras.tables import AssociatedContactsTable
-from nautobot.extras.utils import get_base_template
 
 
 class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
@@ -34,6 +39,9 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
 
     # Log error messages within NautobotHTMLRenderer
     logger = logging.getLogger(__name__)
+    saved_view = None
+
+    exception_template_names = ["%(status_code)s.html"]
 
     def get_dynamic_filter_form(self, view, request, *args, filterset_class=None, **kwargs):
         """
@@ -44,7 +52,9 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         filterset = None
         if filterset_class:
             filterset = filterset_class()
-            factory_formset_params = convert_querydict_to_factory_formset_acceptable_querydict(request.GET, filterset)
+            factory_formset_params = convert_querydict_to_factory_formset_acceptable_querydict(
+                view.filter_params if view.filter_params is not None else request.GET, filterset
+            )
         return DynamicFilterFormSet(filterset=filterset, data=factory_formset_params)
 
     def construct_user_permissions(self, request, model):
@@ -64,14 +74,32 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         """
         table_class = view.get_table_class()
         request = kwargs.get("request", view.request)
+        saved_view_pk = request.GET.get("saved_view", None)
+        table_changes_pending = request.GET.get("table_changes_pending", False)
         queryset = view.alter_queryset(request)
 
         if view.action in ["list", "notes", "changelog"]:
             if view.action == "list":
                 permissions = kwargs.get("permissions", {})
-                if view.request.GET.getlist("sort"):
+                self.saved_view = None
+                if saved_view_pk is not None:
+                    try:
+                        # We are not using .restrict(request.user, "view") here
+                        # User should be able to see any saved view that he has the list view access to.
+                        self.saved_view = SavedView.objects.get(pk=saved_view_pk)
+                    except ObjectDoesNotExist:
+                        pass
+                if view.request.GET.getlist("sort") or (
+                    self.saved_view is not None and self.saved_view.config.get("sort_order")
+                ):
                     view.hide_hierarchy_ui = True  # hide tree hierarchy if custom sort is used
-                table = table_class(queryset, user=request.user, hide_hierarchy_ui=view.hide_hierarchy_ui)
+                table = table_class(
+                    queryset,
+                    table_changes_pending=table_changes_pending,
+                    saved_view=self.saved_view,
+                    user=request.user,
+                    hide_hierarchy_ui=view.hide_hierarchy_ui,
+                )
                 if "pk" in table.base_columns and (permissions["change"] or permissions["delete"]):
                     table.columns.show("pk")
             elif view.action == "notes":
@@ -93,7 +121,7 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
             # Apply the request context
             paginate = {
                 "paginator_class": EnhancedPaginator,
-                "per_page": get_paginate_count(request),
+                "per_page": get_paginate_count(request, self.saved_view),
             }
             max_page_size = get_settings_or_config("MAX_PAGE_SIZE")
             if max_page_size and paginate["per_page"] > max_page_size:
@@ -129,6 +157,30 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
             messages.error(request, f"Missing views for action(s) {', '.join(invalid_actions)}")
         return valid_actions
 
+    def get_template_context(self, data, renderer_context):
+        # borrowed from rest_framework's TemplateHTMLRenderer - should our html renderer be based on that class?
+        response = renderer_context["response"]
+        if response.exception:
+            data["status_code"] = response.status_code
+        return data
+
+    def get_exception_template(self, response):
+        # borrowed from rest_framework's TemplateHTMLRenderer - remove if switching base class
+        template_names = [name % {"status_code": response.status_code} for name in self.exception_template_names]
+
+        try:
+            # Try to find an appropriate error template
+            return self.resolve_template(template_names)
+        except Exception:
+            # Fall back to using eg '404 Not Found'
+            body = f"{response.status_code} {response.status_text.title()}"
+            template = engines["django"].from_string(body)
+            return template
+
+    def resolve_template(self, template_names):
+        # borrowed from rest_framework's TemplateHTMLRenderer - remove if switching base class
+        return loader.select_template(template_names)
+
     def get_context(self, data, accepted_media_type, renderer_context):
         """
         Override get_context() from BrowsableAPIRenderer to obtain the context data we need to render our templates.
@@ -157,7 +209,7 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         display_filter_params = []
         # Compile a dictionary indicating which permissions are available to the current user for this model
         permissions = self.construct_user_permissions(request, model)
-        if view.action in ["create", "retrieve", "update", "destroy", "changelog", "notes"]:
+        if view.detail or view.action == "create":
             instance = view.get_object()
             return_url = view.get_return_url(request, instance)
         else:
@@ -179,9 +231,9 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
                         for field_name, values in view.filter_params.items()
                     ]
                     if view.filterset_form_class is not None:
-                        filter_form = view.filterset_form_class(request.GET, label_suffix="")
+                        filter_form = view.filterset_form_class(view.filter_params, label_suffix="")
                 table = self.construct_table(view, request=request, permissions=permissions)
-                search_form = SearchForm(data=request.GET)
+                search_form = SearchForm(data=view.filter_params)
             elif view.action == "destroy":
                 form = form_class(initial=request.GET)
             elif view.action in ["create", "update"]:
@@ -238,52 +290,56 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
             "verbose_name_plural": queryset.model._meta.verbose_name_plural,
         }
         if view.action == "retrieve":
-            created_by, last_updated_by = get_created_and_last_updated_usernames_for_model(instance)
+            context.update(common_detail_view_context(request, instance))
+        elif view.action == "list":
+            # Construct valid actions for list view.
+            valid_actions = self.validate_action_buttons(view, request)
+            # Query SavedViews for dropdown button
+            list_url = validated_viewname(model, "list")
+            saved_views = None
+            if model.is_saved_view_model:
+                # We are not using .restrict(request.user, "view") here
+                # User should be able to see any saved view that he has the list view access to.
+                if request.user.has_perms(["extras.view_savedview"]):
+                    saved_views = SavedView.objects.filter(view=list_url).order_by("name").only("pk", "name")
+                else:
+                    shared_saved_views = (
+                        SavedView.objects.filter(view=list_url, is_shared=True).order_by("name").only("pk", "name")
+                    )
+                    user_owned_saved_views = (
+                        SavedView.objects.filter(view=list_url, owner=request.user).order_by("name").only("pk", "name")
+                    )
+                    saved_views = shared_saved_views | user_owned_saved_views
 
-            context["created_by"] = created_by
-            context["last_updated_by"] = last_updated_by
-            if instance.is_contact_associable_model:
-                paginate = {"paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request)}
-                associations = instance.associated_contacts.restrict(request.user, "view").order_by("role__name")
-                associations_table = AssociatedContactsTable(associations, orderable=False)
-                RequestConfig(request, paginate).configure(associations_table)
-                associations_table.columns.show("pk")
-                context["associated_contacts_table"] = associations_table
-            else:
-                context["associated_contacts_table"] = None
-            context.update(view.get_extra_context(request, instance))
-        else:
-            if view.action == "list":
-                # Construct valid actions for list view.
-                valid_actions = self.validate_action_buttons(view, request)
-                context.update(
-                    {
-                        "action_buttons": valid_actions,
-                        "list_url": validated_viewname(model, "list"),
-                        "title": bettertitle(model._meta.verbose_name_plural),
-                    }
-                )
-            elif view.action in ["create", "update"]:
-                context.update(
-                    {
-                        "editing": instance.present_in_database,
-                    }
-                )
-            elif view.action == "bulk_create":  # 3.0 TODO: remove, replaced by ImportObjects system Job
-                context.update(
-                    {
-                        "active_tab": view.bulk_create_active_tab if view.bulk_create_active_tab else "csv-data",
-                        "fields": get_csv_form_fields_from_serializer_class(view.serializer_class),
-                    }
-                )
-            elif view.action in ["changelog", "notes"]:
-                context.update(
-                    {
-                        "base_template": get_base_template(data.get("base_template"), model),
-                        "active_tab": view.action,
-                    }
-                )
-            context.update(view.get_extra_context(request, instance=None))
+            new_changes_not_applied = view_changes_not_saved(request, view, self.saved_view)
+            context.update(
+                {
+                    "model": model,
+                    "current_saved_view": self.saved_view,
+                    "new_changes_not_applied": new_changes_not_applied,
+                    "action_buttons": valid_actions,
+                    "list_url": list_url,
+                    "saved_views": saved_views,
+                    "title": bettertitle(model._meta.verbose_name_plural),
+                }
+            )
+        elif view.action in ["create", "update"]:
+            context.update(
+                {
+                    "editing": instance.present_in_database,
+                }
+            )
+        elif view.action == "bulk_create":  # 3.0 TODO: remove, replaced by ImportObjects system Job
+            context.update(
+                {
+                    "active_tab": view.bulk_create_active_tab if view.bulk_create_active_tab else "csv-data",
+                    "fields": get_csv_form_fields_from_serializer_class(view.serializer_class),
+                }
+            )
+
+        # Ensure the proper inheritance of context variables is applied: the view's returned data takes priority over the viewset's get_extra_context
+        context.update(view.get_extra_context(request, instance))
+        context.update(self.get_template_context(data, renderer_context))
         return context
 
     def render(self, data, accepted_media_type=None, renderer_context=None):
@@ -291,6 +347,15 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         Overrode render() from BrowsableAPIRenderer to set self.template with NautobotViewSet's get_template_name() before it is rendered.
         """
         view = renderer_context["view"]
+        request = renderer_context["request"]
+        response = renderer_context["response"]
+
+        # TODO: borrowed from TemplateHTMLRenderer. Remove when switching base class
+        if response.exception:
+            template = self.get_exception_template(response)
+            context = self.get_context(data, accepted_media_type, renderer_context)
+            return template.render(context, request=request)
+
         # Get the corresponding template based on self.action in view.get_template_name() unless it is already specified in the Response() data.
         # See form_valid() for self.action == "bulk_create".
         self.template = data.get("template", view.get_template_name())

nautobot/core/views/utils.py

@@ -7,6 +7,7 @@ from django.core.exceptions import FieldError, ValidationError
 from django.db.models import ForeignKey
 from django.utils.html import format_html, format_html_join
 from django.utils.safestring import mark_safe
+from django_tables2 import RequestConfig
 from rest_framework import exceptions, serializers
 
 from nautobot.core.api.fields import ChoiceField, ContentTypeField, TimeZoneSerializerField
@@ -14,7 +15,9 @@ from nautobot.core.api.parsers import NautobotCSVParser
 from nautobot.core.models.utils import is_taggable
 from nautobot.core.utils.data import is_uuid
 from nautobot.core.utils.filtering import get_filter_field_label
-from nautobot.core.utils.lookup import get_form_for_model
+from nautobot.core.utils.lookup import get_created_and_last_updated_usernames_for_model, get_form_for_model
+from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
+from nautobot.extras.tables import AssociatedContactsTable, DynamicGroupTable, ObjectMetadataTable
 
 
 def check_filter_for_display(filters, field_name, values):
@@ -291,3 +294,80 @@ def prepare_cloned_fields(instance):
     param_string = urllib.parse.urlencode(params)
 
     return param_string
+
+
+def view_changes_not_saved(request, view, current_saved_view):
+    """
+    Compare request.GET's query dict with the configuration stored on the current saved view
+    If there is any configuration different, return True
+    If every configuration is the same, return False
+    """
+    if current_saved_view is None:
+        return True
+    query_dict = request.GET.dict()
+
+    if "table_changes_pending" in query_dict or "all_filters_removed" in query_dict:
+        return True
+    per_page = int(query_dict.get("per_page", 0))
+    if per_page and per_page != current_saved_view.config.get("pagination_count"):
+        return True
+    sort = request.GET.getlist("sort", [])
+    if sort and sort != current_saved_view.config.get("sort_order", []):
+        return True
+    query_dict_keys = sorted(list(query_dict.keys()))
+    for param in view.non_filter_params:
+        if param in query_dict_keys:
+            query_dict_keys.remove(param)
+    filter_params = current_saved_view.config.get("filter_params", {})
+
+    if query_dict_keys:
+        if set(query_dict_keys) != set(filter_params.keys()):
+            return True
+        for key, value in filter_params.items():
+            if set(value) != set(request.GET.getlist(key)):
+                return True
+    return False
+
+
+def common_detail_view_context(request, instance):
+    """Additional template context for object detail views, shared by both ObjectView and NautobotHTMLRenderer."""
+    context = {}
+
+    created_by, last_updated_by = get_created_and_last_updated_usernames_for_model(instance)
+    context["created_by"] = created_by
+    context["last_updated_by"] = last_updated_by
+
+    if instance.is_contact_associable_model:
+        paginate = {"paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request)}
+        associations = instance.associated_contacts.restrict(request.user, "view").order_by("role__name")
+        associations_table = AssociatedContactsTable(associations, orderable=False)
+        RequestConfig(request, paginate).configure(associations_table)
+        associations_table.columns.show("pk")
+        context["associated_contacts_table"] = associations_table
+    else:
+        context["associated_contacts_table"] = None
+
+    if instance.is_dynamic_group_associable_model:
+        paginate = {"paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request)}
+        dynamic_groups = instance.dynamic_groups.restrict(request.user, "view")
+        dynamic_groups_table = DynamicGroupTable(dynamic_groups, orderable=False)
+        dynamic_groups_table.columns.hide("content_type")
+        RequestConfig(request, paginate).configure(dynamic_groups_table)
+        # dynamic_groups_table.columns.show("pk")  # we don't have any supported bulk ops here presently
+        context["associated_dynamic_groups_table"] = dynamic_groups_table
+    else:
+        context["associated_dynamic_groups_table"] = None
+
+    if instance.is_metadata_associable_model:
+        paginate = {"paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request)}
+        object_metadata = instance.associated_object_metadata.restrict(request.user, "view").order_by(
+            "metadata_type", "scoped_fields"
+        )
+        object_metadata_table = ObjectMetadataTable(object_metadata, orderable=False)
+        object_metadata_table.columns.hide("assigned_object")
+        RequestConfig(request, paginate).configure(object_metadata_table)
+        context["associated_object_metadata_table"] = object_metadata_table
+    else:
+        context["associated_object_metadata_table"] = None
+
+    return context

nautobot/dcim/__init__.py

@@ -1 +0,0 @@
-default_app_config = "nautobot.dcim.apps.DCIMConfig"