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

nautobot/core/views/__init__.py

@@ -7,14 +7,15 @@ import time
 from db_file_storage.views import get_file
 from django.apps import apps
 from django.conf import settings
+from django.contrib import messages
 from django.contrib.auth.decorators import permission_required
-from django.contrib.auth.mixins import AccessMixin, LoginRequiredMixin
+from django.contrib.auth.mixins import AccessMixin, LoginRequiredMixin, UserPassesTestMixin
 from django.contrib.contenttypes.models import ContentType
 from django.http import HttpResponseForbidden, HttpResponseServerError, JsonResponse
 from django.shortcuts import get_object_or_404, render
 from django.template import loader, RequestContext, Template
 from django.template.exceptions import TemplateDoesNotExist
-from django.urls import resolve, reverse
+from django.urls import NoReverseMatch, resolve, reverse
 from django.utils.encoding import smart_str
 from django.views.csrf import csrf_failure as _csrf_failure
 from django.views.decorators.csrf import requires_csrf_token
@@ -37,6 +38,7 @@ from rest_framework.response import Response
 from rest_framework.versioning import AcceptHeaderVersioning
 from rest_framework.views import APIView
 
+from nautobot.core.celery import app
 from nautobot.core.constants import SEARCH_MAX_RESULTS
 from nautobot.core.forms import SearchForm
 from nautobot.core.releases import get_latest_release
@@ -125,6 +127,112 @@ class HomeView(AccessMixin, TemplateView):
         return self.render_to_response(context)
 
 
+class WorkerStatusView(UserPassesTestMixin, TemplateView):
+    template_name = "utilities/worker_status.html"
+
+    def test_func(self):
+        return self.request.user.is_staff
+
+    def get(self, request, *args, **kwargs):
+        from nautobot.extras.models import JobResult
+        from nautobot.extras.tables import JobResultTable
+
+        # Sort queues but move the default queue to the front so that it appears first
+        def sort_queues(queue):
+            return (queue != settings.CELERY_TASK_DEFAULT_QUEUE, queue)  # False sorts before true in Python sorted
+
+        # Sort workers on hostname first, then worker name -- celery worker names are in the form name@hostname (celery@worker.example.com)
+        def sort_workers(worker):
+            return list(reversed(worker.split("@")))
+
+        # Use a long timeout to retrieve the initial list of workers
+        max_timeout = 60
+        timeout = request.GET.get("timeout", "5")
+        if not timeout.isdigit():
+            timeout = 5
+        elif int(timeout) > max_timeout:
+            timeout = max_timeout
+        else:
+            timeout = int(timeout)
+        celery_inspect = app.control.inspect(timeout=timeout)
+
+        # stats() returns a dict of {worker_name: stats_dict}
+        worker_stats = celery_inspect.stats()
+
+        if worker_stats:
+            # Set explicit list of workers to speed up subsequent queries
+            celery_inspect = app.control.inspect(list(worker_stats.keys()), timeout=5.0)
+
+            # active() returns a dict of {worker_name: [task_dict, task_dict, ...]}
+            active_tasks = celery_inspect.active() or {}
+
+            # reserved() returns a dict of {worker_name: [task_dict, task_dict, ...]}
+            reserved_tasks = celery_inspect.reserved() or {}
+
+            # active_queues() returns a dict of {worker_name: [queue_dict, queue_dict, ...]}
+            active_queues = celery_inspect.active_queues() or {}
+        else:
+            # No workers were found, default to empty dicts for all commands
+            worker_stats = active_tasks = reserved_tasks = active_queues = {}
+
+        workers = []
+        for worker_name in sorted(worker_stats, key=sort_workers):
+            worker_details = worker_stats[worker_name]
+            active_task_job_results = JobResult.objects.filter(
+                id__in=[task["id"] for task in active_tasks.get(worker_name, [])]
+            ).only("name", "date_created")
+            reserved_task_job_results = JobResult.objects.filter(
+                id__in=[task["id"] for task in reserved_tasks.get(worker_name, [])]
+            ).only("name", "date_created")
+            running_tasks_table = JobResultTable(
+                active_task_job_results, exclude=["actions", "job_model", "summary", "user", "status"]
+            )
+            pending_tasks_table = JobResultTable(
+                reserved_task_job_results, exclude=["actions", "job_model", "summary", "user", "status"]
+            )
+
+            # Sort the worker's queue list
+            queues = sorted([queue["name"] for queue in active_queues.get(worker_name, [])], key=sort_queues)
+
+            workers.append(
+                {
+                    "hostname": worker_name,
+                    "running_tasks_table": running_tasks_table,
+                    "pending_tasks_table": pending_tasks_table,
+                    "queues": queues,
+                    "uptime": worker_details["uptime"],
+                }
+            )
+
+        # Count the number of workers per queue
+        queue_worker_count = {
+            settings.CELERY_TASK_DEFAULT_QUEUE: set(),
+        }
+        for worker_name, task_queue_list in active_queues.items():
+            distinct_queues = {q["name"] for q in task_queue_list}
+            for queue in distinct_queues:
+                queue_worker_count.setdefault(queue, set())
+                queue_worker_count[queue].add(worker_name)
+
+        # Sort the queue_worker_count dictionary by queue name, then by worker hostname/name
+        # Then make the default queue the first entry
+        queue_worker_count = {
+            queue_name: sorted(queue_worker_count[queue_name], key=sort_workers)
+            for queue_name in sorted(queue_worker_count, key=sort_queues)
+        }
+
+        context = {
+            "worker_status": {
+                "max_timeout": max_timeout,
+                "queue_worker_count": queue_worker_count,
+                "timeout": timeout,
+                "workers": workers,
+            },
+        }
+
+        return self.render_to_response(context)
+
+
 class ThemePreviewView(LoginRequiredMixin, TemplateView):
     template_name = "utilities/theme_preview.html"
 
@@ -132,6 +240,8 @@ class ThemePreviewView(LoginRequiredMixin, TemplateView):
         return {
             "content_type": ContentType.objects.get_for_model(Status),
             "object": Status.objects.first(),
+            "verbose_name": Status.objects.all().model._meta.verbose_name,
+            "verbose_name_plural": Status.objects.all().model._meta.verbose_name_plural,
         }
 
 
@@ -177,28 +287,31 @@ class SearchView(AccessMixin, View):
                 # corresponding to that URL, and finally the queryset, filterset, and table classes needed
                 # to find and display the model search results.
                 url = get_route_for_model(f"{label}.{modelname}", "list")
-                view_func = resolve(reverse(url)).func
-                # For a UIViewSet, view_func.cls gets what we need; for an ObjectListView, view_func.view_class is it.
-                view_or_viewset = getattr(view_func, "cls", getattr(view_func, "view_class", None))
-                queryset = view_or_viewset.queryset.restrict(request.user, "view")
-                # For a UIViewSet, .filterset_class, for an ObjectListView, .filterset.
-                filterset = getattr(view_or_viewset, "filterset_class", getattr(view_or_viewset, "filterset", None))
-                # For a UIViewSet, .table_class, for an ObjectListView, .table.
-                table = getattr(view_or_viewset, "table_class", getattr(view_or_viewset, "table", None))
-
-                # Construct the results table for this object type
-                filtered_queryset = filterset({"q": form.cleaned_data["q"]}, queryset=queryset).qs
-                table = table(filtered_queryset, orderable=False)
-                table.paginate(per_page=SEARCH_MAX_RESULTS)
-
-                if table.page:
-                    results.append(
-                        {
-                            "name": queryset.model._meta.verbose_name_plural,
-                            "table": table,
-                            "url": f"{reverse(url)}?q={form.cleaned_data.get('q')}",
-                        }
-                    )
+                try:
+                    view_func = resolve(reverse(url)).func
+                    # For UIViewSet, view_func.cls gets what we need; for an ObjectListView, view_func.view_class is it.
+                    view_or_viewset = getattr(view_func, "cls", getattr(view_func, "view_class", None))
+                    queryset = view_or_viewset.queryset.restrict(request.user, "view")
+                    # For a UIViewSet, .filterset_class, for an ObjectListView, .filterset.
+                    filterset = getattr(view_or_viewset, "filterset_class", getattr(view_or_viewset, "filterset", None))
+                    # For a UIViewSet, .table_class, for an ObjectListView, .table.
+                    table = getattr(view_or_viewset, "table_class", getattr(view_or_viewset, "table", None))
+
+                    # Construct the results table for this object type
+                    filtered_queryset = filterset({"q": form.cleaned_data["q"]}, queryset=queryset).qs
+                    table = table(filtered_queryset, orderable=False)
+                    table.paginate(per_page=SEARCH_MAX_RESULTS)
+
+                    if table.page:
+                        results.append(
+                            {
+                                "name": queryset.model._meta.verbose_name_plural,
+                                "table": table,
+                                "url": f"{reverse(url)}?q={form.cleaned_data.get('q')}",
+                            }
+                        )
+                except NoReverseMatch:
+                    messages.error(request, f'Missing URL "{url}" - unable to show search results for {modelname}.')
 
         return render(
             request,

nautobot/core/views/generic.py

@@ -5,6 +5,7 @@ import re
 from django.conf import settings
 from django.contrib import messages
 from django.contrib.auth.mixins import LoginRequiredMixin
+from django.contrib.auth.models import AnonymousUser
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import (
     FieldDoesNotExist,
@@ -12,10 +13,11 @@ from django.core.exceptions import (
     ValidationError,
 )
 from django.db import IntegrityError, transaction
-from django.db.models import ManyToManyField, ProtectedError
+from django.db.models import ManyToManyField, ProtectedError, Q
 from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput
-from django.http import HttpResponse, JsonResponse
+from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, redirect, render
+from django.urls import reverse
 from django.utils.encoding import iri_to_uri
 from django.utils.html import format_html
 from django.utils.http import url_has_allowed_host_and_scheme
@@ -38,7 +40,6 @@ 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,
@@ -49,14 +50,15 @@ from nautobot.core.views.mixins import GetReturnURLMixin, ObjectPermissionRequir
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.utils import (
     check_filter_for_display,
+    common_detail_view_context,
     get_csv_form_fields_from_serializer_class,
     handle_protectederror,
     import_csv_helper,
     prepare_cloned_fields,
+    view_changes_not_saved,
 )
 from nautobot.extras.context_managers import deferred_change_logging_for_bulk_operation
-from nautobot.extras.models import ContactAssociation, ExportTemplate
-from nautobot.extras.tables import AssociatedContactsTable
+from nautobot.extras.models import ExportTemplate, SavedView, UserSavedViewAssociation
 from nautobot.extras.utils import bulk_delete_with_bulk_change_logging, remove_prefix_from_cf_key
 
 
@@ -111,53 +113,17 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
         Generic GET handler for accessing an object.
         """
         instance = get_object_or_404(self.queryset, **kwargs)
-        # Get the ObjectChange records to populate the advanced tab information
-        created_by, last_updated_by = get_created_and_last_updated_usernames_for_model(instance)
-
-        # TODO: this feels inelegant - should the tabs lookup be a dedicated endpoint rather than piggybacking
-        # on the object-retrieve endpoint?
-        # TODO: similar functionality probably needed in NautobotUIViewSet as well, not currently present
-        if request.GET.get("viewconfig", None) == "true":
-            # TODO: we shouldn't be importing a private-named function from another module. Should it be renamed?
-            from nautobot.extras.templatetags.plugins import _get_registered_content
-
-            temp_fake_context = {
-                "object": instance,
-                "request": request,
-                "settings": {},
-                "csrf_token": "",
-                "perms": {},
-            }
+        content_type = ContentType.objects.get_for_model(self.queryset.model)
+        context = {
+            "object": instance,
+            "content_type": content_type,
+            "verbose_name": self.queryset.model._meta.verbose_name,
+            "verbose_name_plural": self.queryset.model._meta.verbose_name_plural,
+            **common_detail_view_context(request, instance),
+            **self.get_extra_context(request, instance),
+        }
 
-            plugin_tabs = _get_registered_content(instance, "detail_tabs", temp_fake_context, return_html=False)
-            resp = {"tabs": plugin_tabs}
-            return JsonResponse(resp)
-        else:
-            content_type = ContentType.objects.get_for_model(self.queryset.model)
-            context = {
-                "object": instance,
-                "content_type": content_type,
-                "verbose_name": self.queryset.model._meta.verbose_name,
-                "verbose_name_plural": self.queryset.model._meta.verbose_name_plural,
-                "created_by": created_by,
-                "last_updated_by": last_updated_by,
-                **self.get_extra_context(request, instance),
-            }
-            if instance.is_contact_associable_model:
-                paginate = {"paginator_class": EnhancedPaginator, "per_page": get_paginate_count(request)}
-                associations = (
-                    ContactAssociation.objects.filter(
-                        associated_object_id=instance.id,
-                        associated_object_type=content_type,
-                    )
-                    .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
-            return render(request, self.get_template_name(), context)
+        return render(request, self.get_template_name(), context)
 
 
 class ObjectListView(ObjectPermissionRequiredMixin, View):
@@ -184,12 +150,19 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         "page",  # used by django-tables2.RequestConfig
         "per_page",  # used by get_paginate_count
         "sort",  # table sorting
+        "saved_view",  # saved_view indicator pk or composite keys
+        "table_changes_pending",  # indicator for if there is any table changes not applied to the saved view
+        "all_filters_removed",  # indicator for if all filters have been removed from the saved view
+        "clear_view",  # indicator for if the clear view button is clicked or not
     )
 
     def get_filter_params(self, request):
         """Helper function - take request.GET and discard any parameters that are not used for queryset filtering."""
-        filter_params = request.GET.copy()
-        return get_filterable_params_from_filter_params(filter_params, self.non_filter_params, self.filterset())
+        params = request.GET.copy()
+        filter_params = get_filterable_params_from_filter_params(params, self.non_filter_params, self.filterset())
+        if params.get("saved_view") and not filter_params and not params.get("all_filters_removed"):
+            return SavedView.objects.get(pk=params.get("saved_view")).config.get("filter_params", {})
+        return filter_params
 
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "view")
@@ -225,10 +198,41 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         model = self.queryset.model
         content_type = ContentType.objects.get_for_model(model)
 
+        filter_params = request.GET
+        user = request.user
         display_filter_params = []
         dynamic_filter_form = None
         filter_form = None
         hide_hierarchy_ui = False
+        clear_view = request.GET.get("clear_view", False)
+
+        # If the user clicks on the clear view button, we do not check for global or user defaults
+        if not clear_view and not request.GET.get("saved_view"):
+            # Check if there is a default for this view for this specific user
+            app_label, model_name = model._meta.label.split(".")
+            view_name = f"{app_label}:{model_name.lower()}_list"
+
+            if not isinstance(user, AnonymousUser):
+                try:
+                    user_default_saved_view_pk = UserSavedViewAssociation.objects.get(
+                        user=user, view_name=view_name
+                    ).saved_view.pk
+                    # Saved view should either belong to the user or be public
+                    SavedView.objects.get(
+                        Q(pk=user_default_saved_view_pk),
+                        Q(owner=user) | Q(is_shared=True),
+                    )
+                    sv_url = reverse("extras:savedview", kwargs={"pk": user_default_saved_view_pk})
+                    return redirect(sv_url)
+                except ObjectDoesNotExist:
+                    pass
+
+            # Check if there is a global default for this view
+            try:
+                global_saved_view = SavedView.objects.get(view=view_name, is_global_default=True)
+                return redirect(reverse("extras:savedview", kwargs={"pk": global_saved_view.pk}))
+            except ObjectDoesNotExist:
+                pass
 
         if self.filterset:
             filter_params = self.get_filter_params(request)
@@ -254,7 +258,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
 
             if request.GET:
                 factory_formset_params = convert_querydict_to_factory_formset_acceptable_querydict(
-                    request.GET, filterset
+                    filter_params, filterset
                 )
                 dynamic_filter_form = DynamicFilterFormSet(filterset=filterset, data=factory_formset_params)
             else:
@@ -296,18 +300,50 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
 
         table = None
         table_config_form = None
+        current_saved_view = None
+        current_saved_view_pk = self.request.GET.get("saved_view", None)
+        list_url = validated_viewname(model, "list")
+        # 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 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=user).order_by("name").only("pk", "name")
+            )
+            saved_views = shared_saved_views | user_owned_saved_views
         if self.table:
             # Construct the objects table
-            if self.request.GET.getlist("sort"):
+            if current_saved_view_pk:
+                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.
+                    current_saved_view = SavedView.objects.get(view=list_url, pk=current_saved_view_pk)
+                except ObjectDoesNotExist:
+                    messages.error(request, f"Saved view {current_saved_view_pk} not found")
+            if self.request.GET.getlist("sort") or (
+                current_saved_view is not None and current_saved_view.config.get("sort_order")
+            ):
                 hide_hierarchy_ui = True  # hide tree hierarchy if custom sort is used
-            table = self.table(self.queryset, user=request.user, hide_hierarchy_ui=hide_hierarchy_ui)
+            table_changes_pending = self.request.GET.get("table_changes_pending", False)
+
+            table = self.table(
+                self.queryset,
+                table_changes_pending=table_changes_pending,
+                saved_view=current_saved_view,
+                user=request.user,
+                hide_hierarchy_ui=hide_hierarchy_ui,
+            )
             if "pk" in table.base_columns and (permissions["change"] or permissions["delete"]):
                 table.columns.show("pk")
 
             # Apply the request context
             paginate = {
                 "paginator_class": EnhancedPaginator,
-                "per_page": get_paginate_count(request),
+                "per_page": get_paginate_count(request, current_saved_view),
             }
             RequestConfig(request, paginate).configure(table)
             table_config_form = TableConfigForm(table=table)
@@ -320,10 +356,13 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
 
         # For the search form field, use a custom placeholder.
         q_placeholder = "Search " + bettertitle(model._meta.verbose_name_plural)
-        search_form = SearchForm(data=request.GET, q_placeholder=q_placeholder)
+        search_form = SearchForm(data=filter_params, q_placeholder=q_placeholder)
 
         valid_actions = self.validate_action_buttons(request)
 
+        # Query SavedViews for dropdown button
+        new_changes_not_applied = view_changes_not_saved(request, self, current_saved_view)
+
         context = {
             "content_type": content_type,
             "table": table,
@@ -334,8 +373,12 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
             "filter_form": filter_form,
             "dynamic_filter_form": dynamic_filter_form,
             "search_form": search_form,
-            "list_url": validated_viewname(model, "list"),
+            "list_url": list_url,
             "title": bettertitle(model._meta.verbose_name_plural),
+            "new_changes_not_applied": new_changes_not_applied,
+            "current_saved_view": current_saved_view,
+            "saved_views": saved_views,
+            "model": model,
         }
 
         # `extra_context()` would require `request` access, however `request` parameter cannot simply be
@@ -439,7 +482,12 @@ class ObjectEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     def post(self, request, *args, **kwargs):
         logger = logging.getLogger(__name__ + ".ObjectEditView")
         obj = self.alter_obj(self.get_object(kwargs), request, args, kwargs)
-        form = self.model_form(data=request.POST, files=request.FILES, instance=obj)
+        form = self.model_form(
+            data=request.POST,
+            files=request.FILES,
+            initial=normalize_querydict(request.GET, form_class=self.model_form),
+            instance=obj,
+        )
         restrict_form_fields(form, request.user)
 
         if form.is_valid():
@@ -752,7 +800,9 @@ class ObjectImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
 
                             related_obj_pks = []
                             for i, rel_obj_data in enumerate(data.get(field_name, [])):
-                                f = related_object_form(obj, rel_obj_data)
+                                # add parent object key to related object data
+                                rel_obj_data[obj._meta.verbose_name.replace(" ", "_")] = str(obj.pk)
+                                f = related_object_form(rel_obj_data)
 
                                 for subfield_name, field in f.fields.items():
                                     if subfield_name not in rel_obj_data and hasattr(field, "initial"):
@@ -1210,7 +1260,7 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     Delete objects in bulk.
 
     queryset: Custom queryset to use when retrieving objects (e.g. to select related objects)
-    filter: FilterSet to apply when deleting by QuerySet
+    filterset: FilterSet to apply when deleting by QuerySet
     table: The table used to display devices being deleted
     form: The form class used to delete objects in bulk
     template_name: The name of the template
@@ -1336,7 +1386,7 @@ class ComponentCreateView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View
         return get_permission_for_model(self.queryset.model, "add")
 
     def get(self, request):
-        form = self.form(initial=request.GET)
+        form = self.form(initial=normalize_querydict(request.GET, form_class=self.form))
         model_form = self.model_form(request.GET)
 
         return render(
@@ -1352,8 +1402,8 @@ class ComponentCreateView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View
 
     def post(self, request):
         logger = logging.getLogger(__name__ + ".ComponentCreateView")
-        form = self.form(request.POST, initial=request.GET)
-        model_form = self.model_form(request.POST)
+        form = self.form(request.POST, initial=normalize_querydict(request.GET, form_class=self.form))
+        model_form = self.model_form(request.POST, initial=normalize_querydict(request.GET, form_class=self.model_form))
 
         if form.is_valid():
             new_components = []
@@ -1368,7 +1418,9 @@ class ComponentCreateView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View
                 data["label"] = label
                 if hasattr(form, "get_iterative_data"):
                     data.update(form.get_iterative_data(i))
-                component_form = self.model_form(data)
+                component_form = self.model_form(
+                    data, initial=normalize_querydict(request.GET, form_class=self.model_form)
+                )
 
                 if component_form.is_valid():
                     new_components.append(component_form)