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

nautobot/core/tests/test_jobs.py

@@ -1,12 +1,29 @@
+from datetime import timedelta
 from pathlib import Path
 
 from django.contrib.contenttypes.models import ContentType
+from django.core.cache import cache
+from django.core.files.base import ContentFile
+from django.utils import timezone
 import yaml
 
+from nautobot.core.jobs.cleanup import CleanupTypes
 from nautobot.core.testing import create_job_result_and_run_job, TransactionTestCase
-from nautobot.dcim.models import DeviceType, Location, LocationType, Manufacturer
+from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
-from nautobot.extras.models import Contact, ContactAssociation, ExportTemplate, JobLogEntry, Role, Status
+from nautobot.extras.factory import JobResultFactory, ObjectChangeFactory
+from nautobot.extras.models import (
+    Contact,
+    ContactAssociation,
+    ExportTemplate,
+    FileProxy,
+    JobLogEntry,
+    JobResult,
+    ObjectChange,
+    Role,
+    Status,
+)
+from nautobot.ipam.models import Prefix
 from nautobot.users.models import ObjectPermission
 
 
@@ -204,6 +221,76 @@ class ImportObjectsTestCase(TransactionTestCase):
         )
         self.assertEqual(4, Status.objects.filter(name__startswith="test_status").count())
 
+    def test_csv_import_with_utf_8_with_bom_encoding(self):
+        """
+        A superuser running the job with a .csv file with utf_8 with bom encoding should successfully create all specified objects.
+        Test for bug fix https://github.com/nautobot/nautobot/issues/5812 and https://github.com/nautobot/nautobot/issues/5985
+        """
+
+        status = Status.objects.get(name="Active").pk
+        content = f"prefix,status\n192.168.1.1/32,{status}"
+        content = content.encode("utf-8-sig")
+        filename = "test.csv"
+        csv_file = FileProxy.objects.create(name=filename, file=ContentFile(content, name=filename))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ImportObjects",
+            content_type=ContentType.objects.get_for_model(Prefix).pk,
+            csv_file=csv_file.id,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+        self.assertEqual(
+            1, Prefix.objects.filter(status=Status.objects.get(name="Active"), prefix="192.168.1.1/32").count()
+        )
+        mfr = Manufacturer.objects.create(name="Test Cisco Manufacturer")
+        device_type = DeviceType.objects.create(
+            manufacturer=mfr,
+            model="Cisco CSR1000v",
+            u_height=0,
+        )
+        location_type = LocationType.objects.create(name="Test Location Type")
+        location_type.content_types.set([ContentType.objects.get_for_model(Device)])
+        location = Location.objects.create(
+            name="Device Location",
+            location_type=location_type,
+            status=Status.objects.get_for_model(Location).first(),
+        )
+        role = Role.objects.create(name="Device Status")
+        role.content_types.set([ContentType.objects.get_for_model(Device)])
+        content = "\n".join(
+            [
+                "serial,asset_tag,device_type,location,status,name,role",
+                f"1021C4,CA211,{device_type.pk},{location.pk},{status},Test-AC-01,{role}",
+                f"1021C5,CA212,{device_type.pk},{location.pk},{status},Test-AC-02,{role}",
+            ]
+        )
+        content = content.encode("utf-8-sig")
+        filename = "test.csv"
+        csv_file = FileProxy.objects.create(name=filename, file=ContentFile(content, name=filename))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ImportObjects",
+            content_type=ContentType.objects.get_for_model(Device).pk,
+            csv_file=csv_file.id,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_WARNING).exists()
+        )
+        self.assertFalse(
+            JobLogEntry.objects.filter(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR).exists()
+        )
+        device_1 = Device.objects.get(name="Test-AC-01")
+        device_2 = Device.objects.get(name="Test-AC-02")
+        self.assertEqual(device_1.serial, "1021C4")
+        self.assertEqual(device_2.serial, "1021C5")
+
     def test_csv_import_bad_row(self):
         """A row of incorrect data should fail validation for that object but import all others successfully if `roll_back_if_error` is False."""
         csv_data = self.csv_data.split("\n")
@@ -333,3 +420,118 @@ class ImportObjectsTestCase(TransactionTestCase):
         )
 
         self.assertEqual(associations_job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+
+
+class LogsCleanupTestCase(TransactionTestCase):
+    """
+    Test the LogsCleanup system job.
+    """
+
+    databases = ("default", "job_logs")
+
+    def setUp(self):
+        super().setUp()
+        # Recall that TransactionTestCase truncates the DB after each test case...
+        cache.delete("nautobot.extras.utils.change_logged_models_queryset")
+        if ObjectChange.objects.count() < 2:
+            ObjectChangeFactory.create_batch(40)
+        if JobResult.objects.count() < 2:
+            JobResultFactory.create_batch(20)
+
+    def test_cleanup_without_permission(self):
+        """Job should enforce user permissions on the content-types being deleted."""
+        job_result_count = JobResult.objects.count()
+        job_log_entry_count = JobLogEntry.objects.count()
+        object_change_count = ObjectChange.objects.count()
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            username=self.user.username,
+            cleanup_types=[CleanupTypes.JOB_RESULT],
+            max_age=0,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertEqual(log_error.message, f'User "{self.user}" does not have permission to delete JobResult records')
+        self.assertEqual(JobResult.objects.count(), job_result_count + 1)
+        self.assertGreater(JobLogEntry.objects.count(), job_log_entry_count)
+        self.assertEqual(ObjectChange.objects.count(), object_change_count)
+
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            username=self.user.username,
+            cleanup_types=[CleanupTypes.OBJECT_CHANGE],
+            max_age=0,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertEqual(
+            log_error.message, f'User "{self.user}" does not have permission to delete ObjectChange records'
+        )
+        self.assertEqual(JobResult.objects.count(), job_result_count + 2)
+        self.assertGreater(JobLogEntry.objects.count(), job_log_entry_count)
+        self.assertEqual(ObjectChange.objects.count(), object_change_count)
+
+    def test_cleanup_with_constrained_permission(self):
+        """Job should only allow the user to cleanup records they have permission to delete."""
+        job_result_1 = JobResult.objects.last()
+        job_result_2 = JobResult.objects.first()
+        self.assertNotEqual(job_result_1.pk, job_result_2.pk)
+        object_change_1 = ObjectChange.objects.first()
+        object_change_2 = ObjectChange.objects.last()
+        self.assertNotEqual(object_change_1.pk, object_change_2.pk)
+        obj_perm = ObjectPermission(
+            name="Test permission",
+            constraints={"pk__in": [str(job_result_1.pk), str(object_change_1.pk)]},
+            actions=["delete"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(JobResult))
+        obj_perm.object_types.add(ContentType.objects.get_for_model(ObjectChange))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            username=self.user.username,
+            cleanup_types=[CleanupTypes.JOB_RESULT, CleanupTypes.OBJECT_CHANGE],
+            max_age=0,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(job_result.result["extras.JobResult"], 1)
+        self.assertEqual(job_result.result["extras.ObjectChange"], 1)
+        with self.assertRaises(JobResult.DoesNotExist):
+            JobResult.objects.get(pk=job_result_1.pk)
+        JobResult.objects.get(pk=job_result_2.pk)
+        with self.assertRaises(ObjectChange.DoesNotExist):
+            ObjectChange.objects.get(pk=object_change_1.pk)
+        ObjectChange.objects.get(pk=object_change_2.pk)
+
+    def test_cleanup_job_results(self):
+        """With unconstrained permissions, all JobResults before the cutoff should be deleted."""
+        cutoff = timezone.now() - timedelta(days=60)
+        create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            cleanup_types=[CleanupTypes.JOB_RESULT],
+            max_age=60,
+        )
+        self.assertFalse(JobResult.objects.filter(date_done__lt=cutoff).exists())
+        self.assertTrue(JobResult.objects.filter(date_done__gte=cutoff).exists())
+        self.assertTrue(ObjectChange.objects.filter(time__lt=cutoff).exists())
+        self.assertTrue(ObjectChange.objects.filter(time__gte=cutoff).exists())
+
+    def test_cleanup_object_changes(self):
+        """With unconstrained permissions, all ObjectChanges before the cutoff should be deleted."""
+        cutoff = timezone.now() - timedelta(days=60)
+        create_job_result_and_run_job(
+            "nautobot.core.jobs.cleanup",
+            "LogsCleanup",
+            cleanup_types=[CleanupTypes.OBJECT_CHANGE],
+            max_age=60,
+        )
+        self.assertTrue(JobResult.objects.filter(date_done__lt=cutoff).exists())
+        self.assertTrue(JobResult.objects.filter(date_done__gte=cutoff).exists())
+        self.assertFalse(ObjectChange.objects.filter(time__lt=cutoff).exists())
+        self.assertTrue(ObjectChange.objects.filter(time__gte=cutoff).exists())

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_templatetags_netutils.py

@@ -20,15 +20,15 @@ class NautobotTemplateTagsNetutilsTest(TestCase):
                 i = 1
                 for param_name, param in signature.parameters.items():
                     template_string += f" {param_name}="
-                    if param.annotation == str:
+                    if param.annotation is str:
                         template_string += f'"{i}"'
-                    elif param.annotation == bool:
+                    elif param.annotation is bool:
                         template_string += "True"
                     elif param.annotation in (int, float):
                         template_string += str(i)
                     elif param.annotation in (list, tuple):
                         template_string += "[]"
-                    elif param.annotation == dict:
+                    elif param.annotation is dict:
                         template_string += "{}"
                     else:
                         template_string += "None"

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