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

nautobot/core/tests/test_tables.py

@@ -7,9 +7,11 @@ from nautobot.tenancy.tables import TenantGroupTable
 
 
 class TableTestCase(TestCase):
+    maxDiff = None
+
     def _validate_sorted_tree_queryset_same_with_table_queryset(self, queryset, table_class, field_name):
         with self.subTest(f"Assert sorting {table_class.__name__} on '{field_name}'"):
-            table = table_class(queryset, order_by=field_name)
+            table = table_class(queryset.with_tree_fields(), order_by=field_name)
             table_queryset_data = table.data.data.values_list("pk", flat=True)
             sorted_queryset = queryset.with_tree_fields().extra(order_by=[field_name]).values_list("pk", flat=True)
             self.assertEqual(list(table_queryset_data), list(sorted_queryset))

nautobot/core/tests/test_templatetags_helpers.py

@@ -22,14 +22,14 @@ class NautobotTemplatetagsHelperTest(TestCase):
         location.description = ""
         location.save()
         self.assertEqual(
-            helpers.hyperlinked_object(location), f'<a href="/dcim/locations/{location.pk}/">{location.name}</a>'
+            helpers.hyperlinked_object(location), f'<a href="/dcim/locations/{location.pk}/">{location.display}</a>'
         )
         # An object with get_absolute_url and a description gives a titled hyperlink
         location.description = "An important location"
         location.save()
         self.assertEqual(
             helpers.hyperlinked_object(location),
-            f'<a href="/dcim/locations/{location.pk}/" title="An important location">{location.name}</a>',
+            f'<a href="/dcim/locations/{location.pk}/" title="An important location">{location.display}</a>',
         )
         # Optionally you can request a field other than the object's display string
         self.assertEqual(
@@ -114,6 +114,13 @@ class NautobotTemplatetagsHelperTest(TestCase):
         )
         self.assertEqual('"I am UTF-8! 😀"', helpers.render_json("I am UTF-8! 😀", False))
 
+    def test_render_uptime(self):
+        self.assertEqual(helpers.render_uptime(1024768), "11 days 20 hours 39 minutes")
+        self.assertEqual(helpers.render_uptime(""), helpers.placeholder(""))
+        self.assertEqual(helpers.render_uptime("123456"), "1 day 10 hours 17 minutes")
+        self.assertEqual(helpers.render_uptime(0), "0 days 0 hours 0 minutes")
+        self.assertEqual(helpers.render_uptime("foo bar"), helpers.placeholder("foo bar"))
+
     def test_render_yaml(self):
         self.assertEqual(
             helpers.render_yaml({"syntax": "highlight"}), '<code class="language-yaml">syntax: highlight\n</code>'
@@ -251,7 +258,7 @@ class NautobotTemplatetagsHelperTest(TestCase):
             f'<span class="label" style="color: {fbcolor}; background-color: #{color}">{display}</span>',
         )
         # Assert when obj is None
-        self.assertEqual(helpers.hyperlinked_object_with_color(obj=None), "—")
+        self.assertEqual(helpers.hyperlinked_object_with_color(obj=None), '<span class="text-muted">&mdash;</span>')
 
     @override_settings(BANNER_TOP="¡Hola, mundo!")
     @override_config(example_app__SAMPLE_VARIABLE="Testing")
@@ -296,14 +303,14 @@ class NautobotTemplatetagsHelperTest(TestCase):
         location.save()
         self.assertEqual(
             helpers.hyperlinked_object_target_new_tab(location),
-            f'<a href="/dcim/locations/{location.pk}/" target="_blank" rel="noreferrer">{location.name}</a>',
+            f'<a href="/dcim/locations/{location.pk}/" target="_blank" rel="noreferrer">{location.display}</a>',
         )
         # An object with get_absolute_url and a description gives a titled hyperlink
         location.description = "An important location"
         location.save()
         self.assertEqual(
             helpers.hyperlinked_object_target_new_tab(location),
-            f'<a href="/dcim/locations/{location.pk}/" title="An important location" target="_blank" rel="noreferrer">{location.name}</a>',
+            f'<a href="/dcim/locations/{location.pk}/" title="An important location" target="_blank" rel="noreferrer">{location.display}</a>',
         )
         # Optionally you can request a field other than the object's display string
         self.assertEqual(

nautobot/core/tests/test_utils.py

@@ -7,12 +7,12 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.db.models import Q
 from django.http import QueryDict
-from django.test import TestCase
 
 from nautobot.circuits import models as circuits_models
 from nautobot.core import exceptions, forms, settings_funcs
 from nautobot.core.api import utils as api_utils
 from nautobot.core.models import fields as core_fields, utils as models_utils, validators
+from nautobot.core.testing import TestCase
 from nautobot.core.utils import data as data_utils, filtering, lookup, requests
 from nautobot.core.utils.migrations import update_object_change_ct_for_replaced_models
 from nautobot.dcim import filters as dcim_filters, forms as dcim_forms, models as dcim_models, tables
@@ -485,61 +485,61 @@ class LookupRelatedFunctionTest(TestCase):
             location_fields = ["comments", "name", "contact_email", "physical_address", "shipping_address"]
             for field_name in location_fields:
                 form_field = filtering.get_filterset_parameter_form_field(dcim_models.Location, field_name)
-                self.assertIs(type(form_field), forms.MultiValueCharField)
+                self.assertIsInstance(form_field, forms.MultiValueCharField)
 
             device_fields = ["serial", "name"]
             for field_name in device_fields:
                 form_field = filtering.get_filterset_parameter_form_field(dcim_models.Device, field_name)
-                self.assertIs(type(form_field), forms.MultiValueCharField)
+                self.assertIsInstance(form_field, forms.MultiValueCharField)
 
         with self.subTest("Test IntegerField"):
             form_field = filtering.get_filterset_parameter_form_field(dcim_models.Location, "asn")
-            self.assertIs(type(form_field), django_forms.IntegerField)
+            self.assertIsInstance(form_field, django_forms.IntegerField)
 
             device_fields = ["vc_position", "vc_priority"]
             for field_name in device_fields:
                 form_field = filtering.get_filterset_parameter_form_field(dcim_models.Device, field_name)
-                self.assertIs(type(form_field), django_forms.IntegerField)
+                self.assertIsInstance(form_field, django_forms.IntegerField)
 
         with self.subTest("Test DynamicModelMultipleChoiceField"):
             location_fields = ["tenant", "status"]
             for field_name in location_fields:
                 form_field = filtering.get_filterset_parameter_form_field(dcim_models.Location, field_name)
-                self.assertIs(type(form_field), forms.DynamicModelMultipleChoiceField)
+                self.assertIsInstance(form_field, forms.DynamicModelMultipleChoiceField)
 
             device_fields = ["cluster", "device_type", "location"]
             for field_name in device_fields:
                 form_field = filtering.get_filterset_parameter_form_field(dcim_models.Device, field_name)
-                self.assertIs(type(form_field), forms.DynamicModelMultipleChoiceField)
+                self.assertIsInstance(form_field, forms.DynamicModelMultipleChoiceField)
 
             location_fields = ["has_circuit_terminations", "has_devices"]
             for field_name in location_fields:
                 with self.subTest("Test ChoiceField", model=dcim_models.Location, field_name=field_name):
                     form_field = filtering.get_filterset_parameter_form_field(dcim_models.Location, field_name)
-                    self.assertIs(type(form_field), django_forms.ChoiceField)
-                    self.assertIs(type(form_field.widget), forms.StaticSelect2)
+                    self.assertIsInstance(form_field, django_forms.ChoiceField)
+                    self.assertIsInstance(form_field.widget, forms.StaticSelect2)
 
             device_fields = ["has_console_ports", "has_interfaces", "local_config_context_data"]
             for field_name in device_fields:
                 with self.subTest("Test ChoiceField", model=dcim_models.Device, field_name=field_name):
                     form_field = filtering.get_filterset_parameter_form_field(dcim_models.Device, field_name)
-                    self.assertIs(type(form_field), django_forms.ChoiceField)
-                    self.assertIs(type(form_field.widget), forms.StaticSelect2)
+                    self.assertIsInstance(form_field, django_forms.ChoiceField)
+                    self.assertIsInstance(form_field.widget, forms.StaticSelect2)
 
         with self.subTest("Test MultipleChoiceField"):
             form_field = filtering.get_filterset_parameter_form_field(dcim_models.Device, "face")
-            self.assertIs(type(form_field), django_forms.MultipleChoiceField)
+            self.assertIsInstance(form_field, django_forms.MultipleChoiceField)
 
         with self.subTest("Test DateTimePicker"):
             form_field = filtering.get_filterset_parameter_form_field(dcim_models.Location, "last_updated")
-            self.assertIs(type(form_field.widget), forms.DateTimePicker)
+            self.assertIsInstance(form_field.widget, forms.DateTimePicker)
 
             form_field = filtering.get_filterset_parameter_form_field(dcim_models.Device, "last_updated")
-            self.assertIs(type(form_field.widget), forms.DateTimePicker)
+            self.assertIsInstance(form_field.widget, forms.DateTimePicker)
 
         with self.subTest("Test DatePicker"):
             form_field = filtering.get_filterset_parameter_form_field(circuits_models.Circuit, "install_date")
-            self.assertIs(type(form_field.widget), forms.DatePicker)
+            self.assertIsInstance(form_field.widget, forms.DatePicker)
 
         with self.subTest("Test Invalid parameter"):
             with self.assertRaises(exceptions.FilterSetFieldNotFound) as err:
@@ -548,16 +548,27 @@ class LookupRelatedFunctionTest(TestCase):
 
         with self.subTest("Test Content types"):
             form_field = filtering.get_filterset_parameter_form_field(extras_models.Status, "content_types")
-            self.assertIs(type(form_field), forms.MultipleContentTypeField)
+            self.assertIsInstance(form_field, forms.MultipleContentTypeField)
 
             # Assert total ContentTypes generated by form_field is == total `content_types` generated by TaggableClassesQuery
             form_field = filtering.get_filterset_parameter_form_field(extras_models.Tag, "content_types")
-            self.assertIs(type(form_field), forms.MultipleContentTypeField)
-            self.assertEqual(form_field.queryset.count(), extras_utils.TaggableClassesQuery().as_queryset().count())
+            self.assertIsInstance(form_field, forms.MultipleContentTypeField)
+            self.assertQuerysetEqualAndNotEmpty(form_field.queryset, extras_utils.TaggableClassesQuery().as_queryset())
 
             form_field = filtering.get_filterset_parameter_form_field(extras_models.JobHook, "content_types")
-            self.assertIs(type(form_field), forms.MultipleContentTypeField)
-            self.assertEqual(form_field.queryset.count(), extras_utils.ChangeLoggedModelsQuery().as_queryset().count())
+            self.assertIsInstance(form_field, forms.MultipleContentTypeField)
+            self.assertQuerysetEqualAndNotEmpty(
+                form_field.queryset, extras_utils.ChangeLoggedModelsQuery().as_queryset()
+            )
+
+        with self.subTest("Test prefers_id"):
+            form_field = filtering.get_filterset_parameter_form_field(dcim_models.Device, "location")
+            self.assertEqual("id", form_field.to_field_name)
+            form_field = filtering.get_filterset_parameter_form_field(dcim_models.Location, "vlans")
+            self.assertEqual("id", form_field.to_field_name)
+            # Test prefers_id=False (default)
+            form_field = filtering.get_filterset_parameter_form_field(dcim_models.Location, "racks")
+            self.assertEqual("name", form_field.to_field_name)
 
     def test_convert_querydict_to_factory_formset_dict(self):
         location_filter_set = dcim_filters.LocationFilterSet()

nautobot/core/tests/test_views.py

@@ -480,9 +480,9 @@ class ErrorPagesTestCase(TestCase):
     def test_500_default_support_message(self, mock_get):
         """Nautobot's custom 500 page should be used and should include a default support message."""
         url = reverse("home")
-        with self.assertTemplateUsed("500.html"):
-            self.client.raise_request_exception = False
-            response = self.client.get(url)
+        self.client.raise_request_exception = False
+        response = self.client.get(url)
+        self.assertTemplateUsed(response, "500.html")
         self.assertContains(response, "Network to Code", status_code=500)
         response_content = response.content.decode(response.charset)
         self.assertInHTML(
@@ -497,9 +497,9 @@ class ErrorPagesTestCase(TestCase):
     def test_500_custom_support_message(self, mock_get):
         """Nautobot's custom 500 page should be used and should include a custom support message if defined."""
         url = reverse("home")
-        with self.assertTemplateUsed("500.html"):
-            self.client.raise_request_exception = False
-            response = self.client.get(url)
+        self.client.raise_request_exception = False
+        response = self.client.get(url)
+        self.assertTemplateUsed(response, "500.html")
         self.assertNotContains(response, "Network to Code", status_code=500)
         response_content = response.content.decode(response.charset)
         self.assertInHTML("Hello world!", response_content)

nautobot/core/urls.py

@@ -1,6 +1,5 @@
 from django.conf import settings
-from django.conf.urls import include, url
-from django.urls import path
+from django.urls import include, path
 from django.views.generic import TemplateView
 from django.views.static import serve
 
@@ -13,6 +12,7 @@ from nautobot.core.views import (
     SearchView,
     StaticMediaFailureView,
     ThemePreviewView,
+    WorkerStatusView,
 )
 from nautobot.extras.plugins.urls import (
     apps_patterns,
@@ -32,11 +32,14 @@ urlpatterns = [
     path("logout/", LogoutView.as_view(), name="logout"),
     # Apps
     path("circuits/", include("nautobot.circuits.urls")),
+    path("cloud/", include("nautobot.cloud.urls")),
     path("dcim/", include("nautobot.dcim.urls")),
     path("extras/", include("nautobot.extras.urls")),
     path("ipam/", include("nautobot.ipam.urls")),
     path("tenancy/", include("nautobot.tenancy.urls")),
+    # TODO: deprecate this url and use users
     path("user/", include("nautobot.users.urls")),
+    path("users/", include("nautobot.users.urls", "users")),
     path("virtualization/", include("nautobot.virtualization.urls")),
     # API
     path("api/", include("nautobot.core.api.urls")),
@@ -57,12 +60,14 @@ urlpatterns = [
     # django-health-check
     path(r"health/", include("health_check.urls")),
     # FileProxy attachments download/get URLs used in admin views only
-    url(
+    path(
         "files/download/",
         get_file_with_authorization,
         {"add_attachment_headers": True},
         name="db_file_storage.download_file",
     ),
+    # Celery worker status page
+    path("worker-status/", WorkerStatusView.as_view(), name="worker_status"),
     # Templated css file
     path(
         "template.css", TemplateView.as_view(template_name="template.css", content_type="text/css"), name="template_css"

nautobot/core/utils/deprecation.py

@@ -45,3 +45,32 @@ def class_deprecated(message):
 def class_deprecated_in_favor_of(replacement_class):
     """Decorator to mark a class as deprecated and suggest a replacement class if it is subclassed from."""
     return class_deprecated(f"please migrate your code to inherit from class {replacement_class.__name__} instead")
+
+
+def method_deprecated(message):
+    """Decorator to mark a method as deprecated with a custom message about what to call instead."""
+
+    def decorate(method):
+        def decorated_method(*args, **kwargs):
+            warnings.warn(
+                f"Method `{method.__name__}` is deprecated, and will be removed in a future Nautobot release. "
+                f"{message}",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            if LOG_DEPRECATION_WARNINGS:
+                logger.warning(
+                    f"Method `{method.__name__}` is deprecated, and will be removed in a future Nautobot release. "
+                    f"{message}",
+                    stacklevel=2,
+                )
+            return method(*args, **kwargs)
+
+        return decorated_method
+
+    return decorate
+
+
+def method_deprecated_in_favor_of(replacement_method):
+    """Decorator to mark a method as deprecated and suggest a replacement method instead."""
+    return method_deprecated(f"Please migrate your code to call `{replacement_method.__name__}` instead.")

nautobot/core/utils/filtering.py

@@ -96,8 +96,8 @@ def get_filterset_parameter_form_field(model, parameter, filterset=None):
         StaticSelect2Multiple,
     )
     from nautobot.dcim.models import Device
-    from nautobot.extras.filters import ContentTypeMultipleChoiceFilter, CustomFieldFilterMixin, StatusFilter
-    from nautobot.extras.models import ConfigContext, Role, Status, Tag
+    from nautobot.extras.filters import ContentTypeMultipleChoiceFilter, CustomFieldFilterMixin
+    from nautobot.extras.models import ConfigContext
     from nautobot.extras.utils import ChangeLoggedModelsQuery, RoleModelsQuery, TaggableClassesQuery
     from nautobot.virtualization.models import VirtualMachine
 
@@ -114,17 +114,18 @@ def get_filterset_parameter_form_field(model, parameter, filterset=None):
     elif isinstance(field, NumberFilter):
         form_field = forms.IntegerField()
     elif isinstance(field, ModelMultipleChoiceFilter):
-        related_model = Status if isinstance(field, StatusFilter) else field.extra["queryset"].model
+        if getattr(field, "prefers_id", False):
+            to_field_name = "id"
+        else:
+            to_field_name = field.extra.get("to_field_name", "id")
         form_attr = {
-            "queryset": related_model.objects.all(),
-            "to_field_name": field.extra.get("to_field_name", "id"),
+            "queryset": field.extra["queryset"],
+            "to_field_name": to_field_name,
+            "query_params": field.extra.get("query_params", {}),
         }
         # ConfigContext requires content_type set to Device and VirtualMachine
         if model == ConfigContext:
             form_attr["query_params"] = {"content_types": [Device._meta.label_lower, VirtualMachine._meta.label_lower]}
-        # Status and Tag api requires content_type, to limit result to only related content_types
-        elif related_model in [Role, Status, Tag]:
-            form_attr["query_params"] = {"content_types": model._meta.label_lower}
 
         form_field = DynamicModelMultipleChoiceField(**form_attr)
     elif isinstance(
@@ -136,7 +137,9 @@ def get_filterset_parameter_form_field(model, parameter, filterset=None):
         plural_name = slugify_dashes_to_underscores(model._meta.verbose_name_plural)
         # Cable-connectable models use "cable_terminations", not "cables", as the feature name
         if plural_name == "cables":
-            plural_name == "cable_terminations"
+            plural_name = "cable_terminations"
+        elif plural_name == "metadata_types":
+            plural_name = "metadata"
         try:
             form_field = MultipleContentTypeField(choices_as_strings=True, feature=plural_name)
         except KeyError:

nautobot/core/utils/lookup.py

@@ -208,6 +208,40 @@ def get_view_for_model(model, view_type=""):
     return result
 
 
+def get_model_for_view_name(view_name):
+    """
+    Return the model class associated with the given view_name e.g. "circuits:circuit_detail", "dcim:device_list" and etc.
+    If the app_label or model_name contained by the given view_name is invalid, this will return `None`.
+    """
+    app_label, model_name = view_name.split(":")  # dcim, device_list
+    model_name = model_name.split("_")[0]  # device
+
+    try:
+        model = apps.get_model(app_label=app_label, model_name=model_name)
+        return model
+    except LookupError:
+        return None
+
+
+def get_table_class_string_from_view_name(view_name):
+    """Return the name of the TableClass name associated with the view_name
+
+    e.g. returns `LocationTable` for view_name `dcim:location_list`
+
+    Args:
+        view_name (String): The name of the view e.g. dcim:location_list, circuits:circuit_list
+
+    Returns:
+        table_class_name (String): The name of the model table class or None e.g. LocationTable, CircuitTable
+    """
+    model = get_model_for_view_name(view_name)
+    if model:
+        table_class = get_table_for_model(model)
+        if table_class:
+            return table_class.__name__
+    return None
+
+
 def get_created_and_last_updated_usernames_for_model(instance):
     """
     Args:
@@ -224,8 +258,9 @@ def get_created_and_last_updated_usernames_for_model(instance):
     created_by = None
     last_updated_by = None
     try:
-        created_by_record = object_change_records.get(action=ObjectChangeActionChoices.ACTION_CREATE)
-        created_by = created_by_record.user_name
+        created_by_record = object_change_records.filter(action=ObjectChangeActionChoices.ACTION_CREATE).first()
+        if created_by_record is not None:
+            created_by = created_by_record.user_name
     except ObjectChange.DoesNotExist:
         pass
 

nautobot/core/utils/requests.py

@@ -65,7 +65,10 @@ def convert_querydict_to_factory_formset_acceptable_querydict(request_querydict,
                     # the filterset can handle the QueryDict conversion and we can just pass the QueryDict to the filterset
                     # then use the FilterSet to de-dupe the field names
                     lookup_field = re.sub(r"__\w+", "", filter_field_name)
-                lookup_value = request_querydict.getlist(filter_field_name)
+                if isinstance(request_querydict, QueryDict):
+                    lookup_value = request_querydict.getlist(filter_field_name)
+                else:
+                    lookup_value = request_querydict.get(filter_field_name)
 
                 query_dict.setlistdefault(lookup_field_placeholder % num, [lookup_field])
                 query_dict.setlistdefault(lookup_type_placeholder % num, [filter_field_name])

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,