nautobot 2.3.16__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/project-static/js/forms.js

@@ -267,6 +267,11 @@ function initializeDynamicChoiceSelection(context, dropdownParent=null){
                                         let id_prefix = element_id.match(/id_form-[0-9]+-/i, "")[0];
                                         ref_field = $("#" + id_prefix + value.slice(1));
                                     }
+                                    // If the element is in a table row with a class containing "dynamic-formset"
+                                    // We need to find the reference field in the same row
+                                    else if ($(element).closest("tr") && $(element).closest("tr").attr("class") && $(element).closest("tr").attr("class").includes("dynamic-formset")){
+                                        ref_field = $(element).closest("tr").find("select[id*=" + value.slice(1) + "]");
+                                    }
                                     else {
                                         ref_field = $('#id_' + value.slice(1));
                                     }

nautobot/project-static/js/nav_menu.js

@@ -237,8 +237,9 @@ document.addEventListener('DOMContentLoaded', function() {
     if (activeLink) {
         let previouslyClickedLink = document.querySelector('.navbar-fixed-left .navbar-nav > .dropdown > .nav-dropdown-menu > li > a[href="' + activeLink + '"]');
         let currentLocation = window.location.pathname + window.location.search;
+        let previouslyClickedLinkNoSearch = previouslyClickedLink.getAttribute('href').split('?')[0];
 
-        if (previouslyClickedLink && currentLocation.includes(previouslyClickedLink.getAttribute('href'))) {
+        if (previouslyClickedLink && (currentLocation.includes(previouslyClickedLink.getAttribute('href')) || currentLocation.includes(previouslyClickedLinkNoSearch))) {
             previouslyClickedLink.parentElement.classList.add('active');
         }
         else {

nautobot/tenancy/api/serializers.py

@@ -15,7 +15,6 @@ class TenantGroupSerializer(NautobotModelSerializer, TreeModelSerializerMixin):
     class Meta:
         model = TenantGroup
         fields = "__all__"
-        list_display_fields = ["name", "tenant_count", "description", "actions"]
 
 
 class TenantSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
@@ -32,4 +31,3 @@ class TenantSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
     class Meta:
         model = Tenant
         fields = "__all__"
-        list_display_fields = ["name", "tenant_group", "description"]

nautobot/tenancy/factory.py

@@ -45,5 +45,5 @@ class TenantFactory(PrimaryModelFactory):
     has_description = NautobotBoolIterator()
     description = factory.Maybe("has_description", factory.Faker("text", max_nb_chars=CHARFIELD_MAX_LENGTH), "")
 
-    has_tenant_group = NautobotBoolIterator()
+    has_tenant_group = NautobotBoolIterator(chance_of_getting_true=90)
     tenant_group = factory.Maybe("has_tenant_group", random_instance(TenantGroup), None)

nautobot/tenancy/navigation.py

@@ -1,7 +1,4 @@
 from nautobot.core.apps import (
-    NavContext,
-    NavGrouping,
-    NavItem,
     NavMenuAddButton,
     NavMenuGroup,
     NavMenuItem,
@@ -54,29 +51,3 @@ menu_items = (
         ),
     ),
 )
-
-navigation = (
-    NavContext(
-        name="Inventory",
-        groups=(
-            NavGrouping(
-                name="Tenancy",
-                weight=300,
-                items=(
-                    NavItem(
-                        name="Tenants",
-                        weight=100,
-                        link="tenancy:tenant_list",
-                        permissions=["tenancy.view_tenant"],
-                    ),
-                    NavItem(
-                        name="Tenant Groups",
-                        weight=200,
-                        link="tenancy:tenantgroup_list",
-                        permissions=["tenancy.view_tenantgroup"],
-                    ),
-                ),
-            ),
-        ),
-    ),
-)

nautobot/tenancy/templates/tenancy/tenant.html

@@ -1,96 +1,9 @@
 {% extends 'generic/object_detail.html' %}
 {% load helpers %}
+{% load ui_framework %}
 
 {% block extra_breadcrumbs %}
-                {% if object.tenant_group %}
-                    <li><a href="{% url 'tenancy:tenant_list' %}?tenant_group={{ object.tenant_group.name }}">{{ object.tenant_group }}</a></li>
-                {% endif %}
+    {% if object.tenant_group %}
+        <li><a href="{% url 'tenancy:tenant_list' %}?tenant_group={{ object.tenant_group.name }}">{{ object.tenant_group }}</a></li>
+    {% endif %}
 {% endblock extra_breadcrumbs %}
-
-{% block content_left_page %}
-        <div class="panel panel-default">
-            <div class="panel-heading">
-                <strong>Tenant</strong>
-            </div>
-            <table class="table table-hover panel-body attr-table">
-                <tr>
-                    <td>Tenant Group</td>
-                    <td>{{ object.tenant_group|hyperlinked_object }}</td>
-                </tr>
-                <tr>
-                    <td>Description</td>
-                    <td>{{ object.description|placeholder }}</td>
-                </tr>
-            </table>
-        </div>
-        <div class="panel panel-default">
-            <div class="panel-heading">
-                <strong>Comments</strong>
-            </div>
-            <div class="panel-body rendered-markdown">
-                {% if object.comments %}
-                    {{ object.comments|render_markdown }}
-                {% else %}
-                    <span class="text-muted">None</span>
-                {% endif %}
-            </div>
-        </div>
-{% endblock content_left_page %}
-
-{% block content_right_page %}
-        <div class="panel panel-default">
-            <div class="panel-heading">
-                <strong>Stats</strong>
-            </div>
-            <div class="panel-body">
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'circuits:circuit_list' %}?tenant={{ object.name }}" class="btn {% if stats.circuit_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.circuit_count }}</a></h2>
-                    <p>Circuits</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'virtualization:cluster_list' %}?tenant={{ object.name }}" class="btn {% if stats.cluster_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.cluster_count }}</a></h2>
-                    <p>Clusters</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'dcim:device_list' %}?tenant={{ object.name }}" class="btn {% if stats.device_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.device_count }}</a></h2>
-                    <p>Devices</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'extras:dynamicgroup_list' %}?tenant={{ object.name }}" class="btn {% if stats.dynamicgroup_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.dynamicgroup_count }}</a></h2>
-                    <p>Dynamic groups</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'ipam:ipaddress_list' %}?tenant={{ object.name }}" class="btn {% if stats.ipaddress_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.ipaddress_count }}</a></h2>
-                    <p>IP addresses</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'dcim:location_list' %}?tenant={{ object.name }}" class="btn {% if stats.location_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.location_count }}</a></h2>
-                    <p>Locations</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'ipam:prefix_list' %}?tenant={{ object.name }}" class="btn {% if stats.prefix_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.prefix_count }}</a></h2>
-                    <p>Prefixes</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'dcim:rack_list' %}?tenant={{ object.name }}" class="btn {% if stats.rack_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.rack_count }}</a></h2>
-                    <p>Racks</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'dcim:rackreservation_list' %}?tenant={{ object.name }}" class="btn {% if stats.rackreservation_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.rackreservation_count }}</a></h2>
-                    <p>Rack reservations</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'virtualization:virtualmachine_list' %}?tenant={{ object.name }}" class="btn {% if stats.virtualmachine_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.virtualmachine_count }}</a></h2>
-                    <p>Virtual machines</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'ipam:vlan_list' %}?tenant={{ object.name }}" class="btn {% if stats.vlan_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.vlan_count }}</a></h2>
-                    <p>VLANs</p>
-                </div>
-                <div class="col-md-4 text-center">
-                    <h2><a href="{% url 'ipam:vrf_list' %}?tenant={{ object.name }}" class="btn {% if stats.vrf_count %}btn-primary{% else %}btn-default{% endif %} btn-lg">{{ stats.vrf_count }}</a></h2>
-                    <p>VRFs</p>
-                </div>
-            </div>
-        </div>
-{% endblock content_right_page %}

nautobot/tenancy/tests/test_filters.py

@@ -1,13 +1,11 @@
 import factory
 
-from nautobot.circuits.models import Circuit
 from nautobot.core.testing import FilterTestCases
 
 # TODO: move this to nautobot.core.management.commands.generate_test_data and update all impacted tests
 from nautobot.dcim.factory import RackFactory, RackReservationFactory
-from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Platform, Rack, RackReservation
+from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Platform
 from nautobot.extras.models import Role, Status, Tag
-from nautobot.ipam.models import IPAddress, Prefix, RouteTarget, VLAN, VRF
 from nautobot.tenancy.filters import TenantFilterSet, TenantGroupFilterSet
 from nautobot.tenancy.models import Tenant, TenantGroup
 from nautobot.users.factory import UserFactory
@@ -17,18 +15,17 @@ from nautobot.virtualization.factory import (
     ClusterTypeFactory,
     VirtualMachineFactory,
 )
-from nautobot.virtualization.models import Cluster, VirtualMachine
 
 
-class TenantGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class TenantGroupTestCase(FilterTestCases.FilterTestCase):
     queryset = TenantGroup.objects.all()
     filterset = TenantGroupFilterSet
-
-    def test_description(self):
-        params = {
-            "description": TenantGroup.objects.exclude(description__exact="").values_list("description", flat=True)[:2]
-        }
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
+    generic_filter_tests = (
+        ("description",),
+        ("name",),
+        ("tenants", "tenants__id"),
+        ("tenants", "tenants__name"),
+    )
 
     def test_parent(self):
         parent_groups = TenantGroup.objects.filter(children__isnull=False)
@@ -52,19 +49,30 @@ class TenantGroupTestCase(FilterTestCases.NameOnlyFilterTestCase):
             TenantGroup.objects.filter(children__in=[child_groups[0], child_groups[1]]).distinct(),
         )
 
-    def test_tenants(self):
-        """Test the `tenants` filter."""
-        tenants = Tenant.objects.filter(tenant_group__isnull=False)
-        params = {"tenants": [tenants[0].pk, tenants[1].name]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            TenantGroup.objects.filter(tenants__in=[tenants[0], tenants[1]]).distinct(),
-        )
 
-
-class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
+class TenantTestCase(FilterTestCases.FilterTestCase):
     queryset = Tenant.objects.all()
     filterset = TenantFilterSet
+    generic_filter_tests = (
+        ("circuits", "circuits__id"),
+        ("clusters", "clusters__id"),
+        ("clusters", "clusters__name"),
+        ("comments",),
+        ("description",),
+        ("devices", "devices__id"),
+        ("devices", "devices__name"),
+        ("ip_addresses", "ip_addresses__id"),
+        ("name",),
+        ("prefixes", "prefixes__id"),
+        ("rack_reservations", "rack_reservations__id"),
+        ("racks", "racks__id"),
+        ("route_targets", "route_targets__id"),
+        ("route_targets", "route_targets__name"),
+        ("virtual_machines", "virtual_machines__id"),
+        ("virtual_machines", "virtual_machines__name"),
+        ("vlans", "vlans__id"),
+        ("vrfs", "vrfs__id"),
+    )
 
     @classmethod
     def setUpTestData(cls):
@@ -115,42 +123,6 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
         tenant = Tenant.objects.first()
         tenant.tags.set(Tag.objects.all()[:2])
 
-    def test_description(self):
-        params = {
-            "description": Tenant.objects.exclude(description__exact="").values_list("description", flat=True)[:2]
-        }
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
-    def test_comments(self):
-        params = {"comments": Tenant.objects.exclude(comments__exact="").values_list("comments", flat=True)[:2]}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
-    def test_circuits(self):
-        """Test the `circuits` filter."""
-        circuits = list(Circuit.objects.filter(tenant__isnull=False))[:2]
-        params = {"circuits": [circuits[0].pk, circuits[1].pk]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(circuits__in=circuits).distinct(),
-        )
-
-    def test_clusters(self):
-        """Test the `clusters` filter."""
-        clusters = list(Cluster.objects.filter(tenant__isnull=False))[:2]
-        params = {"clusters": [clusters[0].pk, clusters[1].name]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(clusters__in=clusters).distinct(),
-        )
-
-    def test_devices(self):
-        """Test the `devices` filter."""
-        params = {"devices": [self.devices[0].pk, self.devices[1].name]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(devices__in=self.devices).distinct(),
-        )
-
     def test_tenant_group(self):
         groups = list(TenantGroup.objects.filter(tenants__isnull=False))[:2]
         groups_including_children = []
@@ -167,86 +139,9 @@ class TenantTestCase(FilterTestCases.NameOnlyFilterTestCase):
             self.queryset.filter(tenant_group__in=groups_including_children),
         )
 
-    def test_ip_addresses(self):
-        """Test the `ip_addresses` filter."""
-        ip_addresses = list(IPAddress.objects.filter(tenant__isnull=False))[:2]
-        params = {"ip_addresses": [ip_addresses[0].pk, ip_addresses[1].pk]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(ip_addresses__in=ip_addresses).distinct(),
-        )
-
     def test_locations(self):
         params = {"locations": [self.locations[0].pk, self.locations[1].name]}
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs,
             self.queryset.filter(locations__in=[self.locations[0], self.locations[1]]).distinct(),
         )
-
-    def test_prefixes(self):
-        """Test the `prefixes` filter."""
-        prefixes = list(Prefix.objects.filter(tenant__isnull=False))[:2]
-        params = {"prefixes": [prefixes[0].pk, prefixes[1].pk]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(prefixes__in=prefixes).distinct(),
-        )
-
-    def test_rack_reservations(self):
-        """Test the `rack_reservations` filter."""
-        rack_reservations = list(RackReservation.objects.filter(tenant__isnull=False))[:2]
-        params = {"rack_reservations": [rack_reservations[0].pk, rack_reservations[1].pk]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(rack_reservations__in=rack_reservations).distinct(),
-        )
-
-    def test_racks(self):
-        """Test the `racks` filter."""
-        racks = list(Rack.objects.filter(tenant__isnull=False))[:2]
-        params = {"racks": [racks[0].pk, racks[1].pk]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(racks__in=racks).distinct(),
-        )
-
-    def test_route_targets(self):
-        """Test the `route_targets` filter."""
-        route_targets = list(RouteTarget.objects.filter(tenant__isnull=False))[:2]
-        params = {"route_targets": [route_targets[0].pk, route_targets[1].name]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(route_targets__in=route_targets).distinct(),
-        )
-
-    def test_virtual_machines(self):
-        """Test the `virtual_machines` filter."""
-        virtual_machines = list(VirtualMachine.objects.filter(tenant__isnull=False))[:2]
-        params = {"virtual_machines": [virtual_machines[0].pk, virtual_machines[1].name]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(virtual_machines__in=virtual_machines).distinct(),
-        )
-
-    def test_vlans(self):
-        """Test the `vlans` filter."""
-        vlans = list(VLAN.objects.filter(tenant__isnull=False))[:2]
-        params = {"vlans": [vlans[0].pk, vlans[1].pk]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(vlans__in=vlans).distinct(),
-        )
-
-    def test_vrfs(self):
-        """Test the `vrfs` filter."""
-        vrfs = list(VRF.objects.filter(tenant__isnull=False))[:2]
-        params = {"vrfs": [vrfs[0].pk, vrfs[1].pk]}
-        self.assertQuerysetEqualAndNotEmpty(
-            self.filterset(params, self.queryset).qs,
-            self.queryset.filter(vrfs__in=vrfs).distinct(),
-        )
-
-    def test_search(self):
-        params = {"q": self.queryset.first().name}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-        self.assertEqual(self.filterset(params, self.queryset).qs.first(), self.queryset.first())

nautobot/tenancy/views.py

@@ -1,6 +1,8 @@
 from django_tables2 import RequestConfig
 
 from nautobot.circuits.models import Circuit
+from nautobot.core.ui.choices import SectionChoices
+from nautobot.core.ui.object_detail import ObjectDetailContent, ObjectFieldsPanel, StatsPanel
 from nautobot.core.views import generic
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.dcim.models import Device, Location, Rack, RackReservation
@@ -78,29 +80,36 @@ class TenantListView(generic.ObjectListView):
 
 class TenantView(generic.ObjectView):
     queryset = Tenant.objects.select_related("tenant_group")
-
-    def get_extra_context(self, request, instance):
-        stats = {
-            "circuit_count": Circuit.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-            "cluster_count": Cluster.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-            "device_count": Device.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-            "ipaddress_count": IPAddress.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-            # TODO: Should we include child locations of the filtered locations in the location_count below?
-            "location_count": Location.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-            "prefix_count": Prefix.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-            "rack_count": Rack.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-            "rackreservation_count": RackReservation.objects.restrict(request.user, "view")
-            .filter(tenant=instance)
-            .count(),
-            "dynamicgroup_count": DynamicGroup.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-            "virtualmachine_count": VirtualMachine.objects.restrict(request.user, "view")
-            .filter(tenant=instance)
-            .count(),
-            "vlan_count": VLAN.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-            "vrf_count": VRF.objects.restrict(request.user, "view").filter(tenant=instance).count(),
-        }
-
-        return {"stats": stats, **super().get_extra_context(request, instance)}
+    object_detail_content = ObjectDetailContent(
+        panels=(
+            ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+            ),
+            StatsPanel(
+                label="Stats",
+                filter_name="tenant",
+                related_models=[
+                    Circuit,
+                    Cluster,
+                    Device,
+                    IPAddress,
+                    # TODO: Should we include child locations of the filtered locations in the location_count below?
+                    Location,
+                    Prefix,
+                    Rack,
+                    RackReservation,
+                    DynamicGroup,
+                    VirtualMachine,
+                    VLAN,
+                    VRF,
+                ],
+                section=SectionChoices.RIGHT_HALF,
+                weight=100,
+            ),
+        )
+    )
 
 
 class TenantEditView(generic.ObjectEditView):

nautobot/users/admin.py

@@ -12,6 +12,7 @@ from django.utils.html import escape, format_html
 from nautobot.core.admin import NautobotModelAdmin
 from nautobot.core.utils.permissions import qs_filter_from_constraints
 from nautobot.extras.admin import order_content_types
+from nautobot.users.forms import AdminPasswordChangeForm
 from nautobot.users.models import AdminGroup, ObjectPermission, Token, User
 
 #
@@ -44,7 +45,7 @@ class ObjectPermissionInline(admin.TabularInline):
 
 
 class GroupObjectPermissionInline(ObjectPermissionInline):
-    model = AdminGroup.object_permissions.through  # pylint: disable=no-member
+    model = AdminGroup.object_permissions.through
 
 
 class UserObjectPermissionInline(ObjectPermissionInline):
@@ -142,6 +143,7 @@ class UserAdmin(UserAdmin_):
     filter_horizontal = ("groups",)
     formfield_overrides = NautobotModelAdmin.formfield_overrides
     readonly_fields = ("config_data",)
+    change_password_form = AdminPasswordChangeForm
 
     def get_inlines(self, request, obj):
         if obj is not None:

nautobot/users/api/serializers.py

@@ -18,13 +18,13 @@ class UserSerializer(ValidatedModelSerializer):
         exclude = ["user_permissions"]
         extra_kwargs = {"password": {"write_only": True, "required": False, "allow_null": True}}
 
-    def validate(self, attrs):
+    def validate(self, data):
         """Handle omission of a password by setting it to the unusable None value."""
         mock_password = False
-        if "password" not in attrs and not self.partial:
-            attrs["password"] = make_password(None)
+        if "password" not in data and not self.partial:
+            data["password"] = make_password(None)
             mock_password = True
-        validated_data = super().validate(attrs)
+        validated_data = super().validate(data)
         if mock_password:
             validated_data["password"] = None
         return validated_data
@@ -59,7 +59,6 @@ class UserSerializer(ValidatedModelSerializer):
 
 
 class GroupSerializer(ValidatedModelSerializer):
-    id = serializers.IntegerField(read_only=True)
     url = serializers.HyperlinkedIdentityField(view_name="users-api:group-detail")
     user_count = serializers.IntegerField(read_only=True)
 

nautobot/users/api/views.py

@@ -43,7 +43,7 @@ class GroupViewSet(ModelViewSet):
 
 
 class TokenViewSet(ModelViewSet):
-    queryset = RestrictedQuerySet(model=Token).select_related("user")  # pylint: disable=not-callable  # no idea why?
+    queryset = RestrictedQuerySet(model=Token).select_related("user")
     serializer_class = serializers.TokenSerializer
     filterset_class = filters.TokenFilterSet
 

nautobot/users/forms.py

@@ -1,11 +1,16 @@
 from django import forms
 from django.contrib.auth.forms import (
+    AdminPasswordChangeForm as _AdminPasswordChangeForm,
     AuthenticationForm,
     PasswordChangeForm as DjangoPasswordChangeForm,
 )
+from timezone_field import TimeZoneFormField
 
+from nautobot.core.events import publish_event
 from nautobot.core.forms import BootstrapMixin, DateTimePicker
+from nautobot.core.forms.widgets import StaticSelect2
 from nautobot.core.utils.config import get_settings_or_config
+from nautobot.users.utils import serialize_user_without_config_and_views
 
 from .models import Token
 
@@ -64,3 +69,17 @@ class AdvancedProfileSettingsForm(BootstrapMixin, forms.Form):
             raise forms.ValidationError(
                 {"request_profiling": "Request profiling has been globally disabled by an administrator."}
             )
+
+
+class PreferenceProfileSettingsForm(BootstrapMixin, forms.Form):
+    timezone = TimeZoneFormField(required=False, help_text="Set your default timezone", widget=StaticSelect2)
+
+
+class AdminPasswordChangeForm(_AdminPasswordChangeForm):
+    def save(self, commit=True):
+        # Override `_AdminPasswordChangeForm.save()` to publish admin change user password event
+        instance = super().save(commit)
+        if commit:
+            payload = serialize_user_without_config_and_views(instance)
+            publish_event(topic="nautobot.admin.user.change_password", payload=payload)
+        return instance

nautobot/users/templates/users/preferences.html

@@ -1,5 +1,6 @@
 {% extends 'users/base.html' %}
 {% load helpers %}
+{% load form_helpers %}
 
 {% block title %}User Preferences{% endblock %}
 
@@ -32,4 +33,25 @@
     {% else %}
         <h3 class="text-muted text-center">No preferences found</h3>
     {% endif %}
+
+    <form action="" method="post" class="form form-horizontal" style="margin-top: 30px;">
+        {% csrf_token %}
+        {% if form.non_field_errors %}
+            <div class="panel panel-danger">
+                <div class="panel-heading"><strong>Errors</strong></div>
+                <div class="panel-body">
+                    {{ form.non_field_errors }}
+                </div>
+            </div>
+        {% endif %}
+        <div class="panel panel-default">
+            <div class="panel-heading"><strong>Preference Settings</strong></div>
+            <div class="panel-body">
+                {% render_field form.timezone %}
+            </div>
+        </div>
+        <div class="text-right">
+            <button type="submit" name="_update_preference_form" class="btn btn-primary">Update</button>
+        </div>
+    </form>
 {% endblock %}

nautobot/users/tests/test_filters.py

@@ -122,15 +122,11 @@ class UserTestCase(FilterTestCases.FilterTestCase):
             self.filterset(params, self.queryset).qs, self.queryset.filter(is_active=True)
         )
 
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class GroupTestCase(FilterTestCases.FilterTestCase):
     queryset = Group.objects.all()
     filterset = GroupFilterSet
+    generic_filter_tests = (("name",),)
 
     @classmethod
     def setUpTestData(cls):
@@ -138,15 +134,6 @@ class GroupTestCase(FilterTestCases.FilterTestCase):
         Group.objects.create(name="Group 2")
         Group.objects.create(name="Group 3")
 
-    def test_name(self):
-        params = {"name": ["Group 1", "Group 2"]}
-        self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
-
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)
-
 
 class ObjectPermissionTestCase(FilterTestCases.FilterTestCase):
     queryset = ObjectPermission.objects.all()
@@ -261,8 +248,3 @@ class TokenTestCase(FilterTestCases.FilterTestCase):
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 2)
         params = {"write_enabled": False}
         self.assertEqual(self.filterset(params, self.queryset).qs.count(), 1)
-
-    def test_search(self):
-        value = self.queryset.values_list("pk", flat=True)[0]
-        params = {"q": value}
-        self.assertEqual(self.filterset(params, self.queryset).qs.values_list("pk", flat=True)[0], value)