nautobot 2.0.0a3__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/users/api/serializers.py

@@ -1,50 +1,33 @@
-from django.contrib.auth import get_user_model
+from django.contrib.auth import authenticate, get_user_model
+from django.contrib.auth.hashers import make_password
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
 from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
 
 from nautobot.core.api import (
     ContentTypeField,
-    SerializedPKRelatedField,
     ValidatedModelSerializer,
 )
 from nautobot.users.models import ObjectPermission, Token
 
-# Not all of these variable(s) are not actually used anywhere in this file, but required for the
-# automagically replacing a Serializer with its corresponding NestedSerializer.
-from .nested_serializers import (  # noqa: F401
-    NestedGroupSerializer,
-    NestedObjectPermissionSerializer,
-    NestedTokenSerializer,
-    NestedUserSerializer,
-)
-
 
 class UserSerializer(ValidatedModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="users-api:user-detail")
-    groups = SerializedPKRelatedField(
-        queryset=Group.objects.all(),
-        serializer=NestedGroupSerializer,
-        required=False,
-        many=True,
-    )
-
     class Meta:
         model = get_user_model()
-        fields = (
-            "id",
-            "url",
-            "username",
-            "password",
-            "first_name",
-            "last_name",
-            "email",
-            "is_staff",
-            "is_active",
-            "date_joined",
-            "groups",
-        )
-        extra_kwargs = {"password": {"write_only": True}}
+        exclude = ["user_permissions"]
+        extra_kwargs = {"password": {"write_only": True, "required": False, "allow_null": True}}
+
+    def validate(self, data):
+        """Handle omission of a password by setting it to the unusable None value."""
+        mock_password = False
+        if "password" not in data and not self.partial:
+            data["password"] = make_password(None)
+            mock_password = True
+        validated_data = super().validate(data)
+        if mock_password:
+            validated_data["password"] = None
+        return validated_data
 
     def create(self, validated_data):
         """
@@ -57,6 +40,23 @@ class UserSerializer(ValidatedModelSerializer):
 
         return user
 
+    def update(self, instance, validated_data):
+        """
+        Extract the password from validated data and set it separately to ensure proper hash generation.
+        """
+        update_password = False
+        if "password" in validated_data:
+            update_password = True
+            password = validated_data.pop("password")
+        elif not self.partial:
+            update_password = True
+            password = None
+        super().update(instance, validated_data)
+        if update_password:
+            instance.set_password(password)
+            instance.save()
+        return instance
+
 
 class GroupSerializer(ValidatedModelSerializer):
     url = serializers.HyperlinkedIdentityField(view_name="users-api:group-detail")
@@ -64,52 +64,42 @@ class GroupSerializer(ValidatedModelSerializer):
 
     class Meta:
         model = Group
-        fields = ("id", "url", "name", "user_count")
+        exclude = ["permissions"]
 
 
 class TokenSerializer(ValidatedModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="users-api:token-detail")
     key = serializers.CharField(min_length=40, max_length=40, allow_blank=True, required=False)
 
     class Meta:
         model = Token
-        fields = ("id", "url", "display", "created", "expires", "key", "write_enabled", "description")
+        exclude = ["user"]
 
     def to_internal_value(self, data):
         data = super().to_internal_value(data)
-        if "key" not in data:
+        if "key" not in data and not self.instance:
             data["key"] = Token.generate_key()
         data["user"] = self.context["request"].user
         return data
 
 
 class ObjectPermissionSerializer(ValidatedModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="users-api:objectpermission-detail")
     object_types = ContentTypeField(queryset=ContentType.objects.all(), many=True)
-    groups = SerializedPKRelatedField(
-        queryset=Group.objects.all(),
-        serializer=NestedGroupSerializer,
-        required=False,
-        many=True,
-    )
-    users = SerializedPKRelatedField(
-        queryset=get_user_model().objects.all(),
-        serializer=NestedUserSerializer,
-        required=False,
-        many=True,
-    )
 
     class Meta:
         model = ObjectPermission
-        fields = (
-            "id",
-            "url",
-            "name",
-            "description",
-            "enabled",
-            "object_types",
-            "groups",
-            "users",
-            "actions",
-            "constraints",
+        fields = "__all__"
+
+
+class UserLoginSerializer(serializers.Serializer):
+    username = serializers.CharField()
+    password = serializers.CharField()
+
+    def validate(self, attrs):
+        user = authenticate(
+            self.context["request"],
+            username=attrs["username"],
+            password=attrs["password"],
         )
+        if not user:
+            raise ValidationError("Invalid login credentials.")
+        return {"user": user}

nautobot/users/api/urls.py

@@ -1,4 +1,4 @@
-from nautobot.core.api import OrderedDefaultRouter
+from nautobot.core.api.routers import OrderedDefaultRouter
 from . import views
 
 

nautobot/users/api/views.py

@@ -1,9 +1,12 @@
-from django.contrib.auth import get_user_model
+from django.contrib.auth import get_user_model, login, logout
 from django.contrib.auth.models import Group
 from django.db.models import Count
+from django.views.decorators.csrf import ensure_csrf_cookie
+from django.utils.decorators import method_decorator
 from drf_spectacular.utils import extend_schema, extend_schema_view, OpenApiTypes
 from rest_framework.authentication import BasicAuthentication
-from rest_framework.permissions import IsAuthenticated
+from rest_framework.decorators import action
+from rest_framework.permissions import AllowAny, IsAuthenticated
 from rest_framework.response import Response
 from rest_framework.routers import APIRootView
 from rest_framework.viewsets import ViewSet
@@ -36,6 +39,39 @@ class UserViewSet(ModelViewSet):
     serializer_class = serializers.UserSerializer
     filterset_class = filters.UserFilterSet
 
+    @action(methods=["GET"], detail=False, url_path="my-profile")
+    def my_profile(self, request):
+        serializer = self.serializer_class(instance=request.user, context={"request": request})
+        return Response(serializer.data)
+
+    @method_decorator(ensure_csrf_cookie)
+    @action(methods=["GET"], detail=False, permission_classes=[AllowAny])
+    def session(self, request):
+        from django.conf import settings as django_settings
+        from nautobot.core.settings_funcs import sso_auth_enabled
+        from social_django.context_processors import backends
+        from django.urls import reverse
+
+        serializer = self.serializer_class(instance=request.user, context={"request": request})
+
+        _backends = []
+        sso_enabled = sso_auth_enabled(django_settings.AUTHENTICATION_BACKENDS)
+
+        social_auth_backends = backends(request)["backends"]
+        if sso_enabled:
+            for backend in social_auth_backends["backends"]:
+                _backends.append(reverse("social:begin", kwargs={"backend": backend}))
+
+        resp = {
+            "user": serializer.data,
+            "logged_in": request.user.is_authenticated,
+            "sso_enabled": sso_enabled,
+            "sso_user": (len(social_auth_backends["associated"]) > 0),
+            "backends": _backends,
+        }
+
+        return Response(resp)
+
 
 @extend_schema_view(
     bulk_destroy=extend_schema(request=BulkOperationIntegerIDSerializer(many=True)),
@@ -63,6 +99,21 @@ class TokenViewSet(ModelViewSet):
         classes = super().authentication_classes
         return classes + [BasicAuthentication]
 
+    # TODO(timizuo): Move authenticate and logout to its own view;
+    #  as it is not proper to be on this.
+    @action(methods=["POST"], detail=False, permission_classes=[AllowAny])
+    def authenticate(self, request):
+        serializer = serializers.UserLoginSerializer(data=request.data, context=self.get_serializer_context())
+        serializer.is_valid(raise_exception=True)
+        user = serializer.validated_data["user"]
+        login(request, user=user)
+        return Response(status=200)
+
+    @action(methods=["GET"], detail=False)
+    def logout(self, request):
+        logout(request)
+        return Response(status=200)
+
     def get_queryset(self):
         """
         Limit users to their own Tokens.

nautobot/users/tests/test_api.py

@@ -1,16 +1,17 @@
 import base64
+from unittest import skip
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import Group
 from django.contrib.contenttypes.models import ContentType
 from django.urls import reverse
+from django.utils.timezone import now
+from rest_framework import HTTP_HEADER_ENCODING, status
 
-from nautobot.core.testing import APIViewTestCases, APITestCase
+from nautobot.core.testing import APIViewTestCases, APITestCase, get_deletable_objects
 from nautobot.core.utils.data import deepmerge
 from nautobot.users.filters import GroupFilterSet
 from nautobot.users.models import ObjectPermission, Token
 
-from rest_framework import HTTP_HEADER_ENCODING
-
 
 # Use the proper swappable User model
 User = get_user_model()
@@ -26,34 +27,107 @@ class AppTest(APITestCase):
 
 class UserTest(APIViewTestCases.APIViewTestCase):
     model = User
-    brief_fields = ["display", "id", "url", "username"]
     validation_excluded_fields = ["password"]
     create_data = [
         {
-            "username": "User_4",
+            "username": "user_4",
             "password": "password4",
+            "is_superuser": True,
+            "is_staff": True,
+            "is_active": False,
+            "first_name": "Fourth",
+            "last_name": "User",
+            "email": "fourth.user@example.com",
+            "config_data": {
+                "tables": {
+                    "CircuitTable": {
+                        "columns": ["cid", "provider", "status", "tags"],
+                    },
+                },
+            },
+            "date_joined": now(),
         },
         {
-            "username": "User_5",
+            "username": "user_5",
             "password": "password5",
         },
         {
-            "username": "User_6",
-            "password": "password6",
+            "username": "user_6",
         },
     ]
 
     @classmethod
     def setUpTestData(cls):
-        User.objects.create(username="User_1")
-        User.objects.create(username="User_2")
-        User.objects.create(username="User_3")
+        user1 = User.objects.create(username="User_1")
+        user1.set_password(None)
+        user1.save()
+        user2 = User.objects.create(username="User_2")
+        user2.set_password(None)
+        user2.save()
+        user3 = User.objects.create(username="User_3")
+        user3.set_password(None)
+        user3.save()
+        group = Group.objects.create(name="Group 22")
+        cls.update_data = {
+            "username": "user_22",
+            "password": "password22",
+            "is_staff": False,
+            "is_superuser": False,
+            "is_active": True,
+            "groups": [group.pk],
+            "config_data": {
+                "tables": {
+                    "ProviderTable": {
+                        "columns": ["name", "asn", "tags"],
+                    },
+                },
+            },
+        }
+
+    def get_deletable_object(self):
+        """Get an instance that can be deleted, being sure not to delete the test user!"""
+        return User.objects.create(username="User_100")
+
+    def test_create_object(self):
+        """Add validation of the password on the created users."""
+        self.maxDiff = None
+        super().test_create_object()
+        for entry in self.create_data:
+            user = User.objects.get(username=entry["username"])
+            if "password" in entry:
+                self.assertTrue(user.check_password(entry["password"]))
+            else:
+                self.assertFalse(user.has_usable_password())
+
+    def test_recreate_object_csv(self):
+        """Add validation that the recreated user has no password."""
+        super().test_recreate_object_csv()
+        user = User.objects.get(username="User_100")
+        self.assertFalse(user.has_usable_password())
+
+    def test_update_object(self):
+        """Add validation that a partial update can change the password if requested."""
+        user = self._get_queryset().first()
+        super().test_update_object()
+        user.refresh_from_db()
+        self.assertTrue(user.check_password(self.update_data["password"]))
+        # Make sure the password *isn't* changed if we make a PATCH without a specified password
+        response = self.client.patch(self._get_detail_url(user), {}, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertNotIn("password", response.json())
+        user.refresh_from_db()
+        self.assertTrue(user.check_password(self.update_data["password"]))
+
+    def test_get_put_round_trip(self):
+        """Add validation that the password is cleared by a PUT with no specified password."""
+        super().test_get_put_round_trip()
+        user = self._get_queryset().first()
+        self.assertFalse(user.has_usable_password())
 
 
 class GroupTest(APIViewTestCases.APIViewTestCase):
     model = Group
     filterset = GroupFilterSet
-    brief_fields = ["display", "id", "name", "url"]
     create_data = [
         {
             "name": "Group 4",
@@ -83,7 +157,6 @@ class GroupTest(APIViewTestCases.APIViewTestCase):
 
 class TokenTest(APIViewTestCases.APIViewTestCase):
     model = Token
-    brief_fields = ["display", "id", "key", "url", "write_enabled"]
     bulk_update_data = {
         "description": "New description",
     }
@@ -125,9 +198,16 @@ class TokenTest(APIViewTestCases.APIViewTestCase):
             },
         ]
 
+    def get_deletable_object(self):
+        """Get an instance that can be deleted, being sure not to delete the test token!"""
+        instance = get_deletable_objects(self.model, self._get_queryset().exclude(pk=self.token.pk)).first()
+        if instance is None:
+            self.fail("Couldn't find a single deletable object!")
+        return instance
+
     def _create_basic_authentication_header(self, username, password):
         """
-        Given username, password create a valid Basic authenticaition header string.
+        Given username, password create a valid Basic authentication header string.
 
         Same procedure used to test DRF.
         """
@@ -267,17 +347,6 @@ class TokenTest(APIViewTestCases.APIViewTestCase):
 
 class ObjectPermissionTest(APIViewTestCases.APIViewTestCase):
     model = ObjectPermission
-    brief_fields = [
-        "actions",
-        "display",
-        "enabled",
-        "groups",
-        "id",
-        "name",
-        "object_types",
-        "url",
-        "users",
-    ]
 
     @classmethod
     def setUpTestData(cls):
@@ -336,6 +405,22 @@ class ObjectPermissionTest(APIViewTestCases.APIViewTestCase):
             "description": "New description",
         }
 
+    def get_deletable_object(self):
+        return ObjectPermission.objects.create(
+            name="Permission 100",
+            actions=["view", "add", "change", "delete"],
+            constraints={"name": "TEST100"},
+        )
+
+    # TODO: Unskip after resolving #2908, #2909
+    @skip("DRF's built-in OrderingFilter triggering natural key attribute error in our base")
+    def test_list_objects_ascending_ordered(self):
+        pass
+
+    @skip("DRF's built-in OrderingFilter triggering natural key attribute error in our base")
+    def test_list_objects_descending_ordered(self):
+        pass
+
 
 class UserConfigTest(APITestCase):
     def test_get(self):

nautobot/virtualization/api/serializers.py

@@ -3,27 +3,13 @@ from rest_framework import serializers
 
 from nautobot.core.api import (
     ChoiceField,
-    SerializedPKRelatedField,
-)
-from nautobot.dcim.api.nested_serializers import (
-    NestedLocationSerializer,
-    NestedPlatformSerializer,
+    NautobotModelSerializer,
 )
 from nautobot.dcim.api.serializers import InterfaceCommonSerializer
 from nautobot.dcim.choices import InterfaceModeChoices
-from nautobot.extras.api.serializers import (
-    NautobotModelSerializer,
-    RoleModelSerializerMixin,
-    StatusModelSerializerMixin,
+from nautobot.extras.api.mixins import (
     TaggedModelSerializerMixin,
 )
-from nautobot.extras.api.nested_serializers import NestedConfigContextSchemaSerializer
-from nautobot.ipam.api.nested_serializers import (
-    NestedIPAddressSerializer,
-    NestedVLANSerializer,
-)
-from nautobot.ipam.models import IPAddress, VLAN
-from nautobot.tenancy.api.nested_serializers import NestedTenantSerializer
 from nautobot.virtualization.models import (
     Cluster,
     ClusterGroup,
@@ -32,72 +18,34 @@ from nautobot.virtualization.models import (
     VMInterface,
 )
 
-# Not all of these variable(s) are not actually used anywhere in this file, but required for the
-# automagically replacing a Serializer with its corresponding NestedSerializer.
-from .nested_serializers import (  # noqa: F401
-    NestedClusterGroupSerializer,
-    NestedClusterSerializer,
-    NestedClusterTypeSerializer,
-    NestedVirtualMachineSerializer,
-    NestedVMInterfaceSerializer,
-)
-
 #
 # Clusters
 #
 
 
 class ClusterTypeSerializer(NautobotModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="virtualization-api:clustertype-detail")
     cluster_count = serializers.IntegerField(read_only=True)
 
     class Meta:
         model = ClusterType
-        fields = [
-            "url",
-            "name",
-            "description",
-            "cluster_count",
-        ]
+        fields = "__all__"
 
 
 class ClusterGroupSerializer(NautobotModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name="virtualization-api:clustergroup-detail")
     cluster_count = serializers.IntegerField(read_only=True)
 
     class Meta:
         model = ClusterGroup
-        fields = [
-            "url",
-            "name",
-            "description",
-            "cluster_count",
-        ]
+        fields = "__all__"
 
 
 class ClusterSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="virtualization-api:cluster-detail")
-    cluster_type = NestedClusterTypeSerializer()
-    cluster_group = NestedClusterGroupSerializer(required=False, allow_null=True)
-    tenant = NestedTenantSerializer(required=False, allow_null=True)
-    location = NestedLocationSerializer(required=False, allow_null=True)
     device_count = serializers.IntegerField(read_only=True)
     virtualmachine_count = serializers.IntegerField(read_only=True)
 
     class Meta:
         model = Cluster
-        fields = [
-            "url",
-            "name",
-            "cluster_type",
-            "cluster_group",
-            "tenant",
-            "location",
-            "comments",
-            "tags",
-            "device_count",
-            "virtualmachine_count",
-        ]
+        fields = "__all__"
 
 
 #
@@ -105,49 +53,19 @@ class ClusterSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
 #
 
 
-class VirtualMachineSerializer(
-    NautobotModelSerializer, TaggedModelSerializerMixin, StatusModelSerializerMixin, RoleModelSerializerMixin
-):
-    url = serializers.HyperlinkedIdentityField(view_name="virtualization-api:virtualmachine-detail")
-    location = NestedLocationSerializer(read_only=True, required=False, allow_null=True)
-    cluster = NestedClusterSerializer()
-    tenant = NestedTenantSerializer(required=False, allow_null=True)
-    platform = NestedPlatformSerializer(required=False, allow_null=True)
-    primary_ip = NestedIPAddressSerializer(read_only=True)
-    primary_ip4 = NestedIPAddressSerializer(required=False, allow_null=True)
-    primary_ip6 = NestedIPAddressSerializer(required=False, allow_null=True)
-    local_config_context_schema = NestedConfigContextSchemaSerializer(required=False, allow_null=True)
+class VirtualMachineSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
+    config_context = serializers.SerializerMethodField()
 
     class Meta:
         model = VirtualMachine
-        fields = [
-            "url",
-            "name",
-            "status",
-            "location",
-            "cluster",
-            "role",
-            "tenant",
-            "platform",
-            "primary_ip",
-            "primary_ip4",
-            "primary_ip6",
-            "vcpus",
-            "memory",
-            "disk",
-            "comments",
-            "local_config_context_data",
-            "local_config_context_schema",
-        ]
+        fields = "__all__"
         validators = []
 
-
-class VirtualMachineWithConfigContextSerializer(VirtualMachineSerializer):
-    config_context = serializers.SerializerMethodField()
-    local_config_context_schema = NestedConfigContextSchemaSerializer(required=False, allow_null=True)
-
-    class Meta(VirtualMachineSerializer.Meta):
-        fields = VirtualMachineSerializer.Meta.fields + ["config_context"]
+    def get_field_names(self, declared_fields, info):
+        """Config context is expensive to compute and so it's opt-in only."""
+        fields = list(super().get_field_names(declared_fields, info))
+        self.extend_field_names(fields, "config_context", opt_in_only=True)
+        return fields
 
     @extend_schema_field(serializers.DictField)
     def get_config_context(self, obj):
@@ -159,45 +77,15 @@ class VirtualMachineWithConfigContextSerializer(VirtualMachineSerializer):
 #
 
 
-class VMInterfaceSerializer(InterfaceCommonSerializer, StatusModelSerializerMixin):
-    url = serializers.HyperlinkedIdentityField(view_name="virtualization-api:vminterface-detail")
-    virtual_machine = NestedVirtualMachineSerializer()
+class VMInterfaceSerializer(
+    InterfaceCommonSerializer,
+):
     mode = ChoiceField(choices=InterfaceModeChoices, allow_blank=True, required=False)
-    untagged_vlan = NestedVLANSerializer(required=False, allow_null=True)
-    tagged_vlans = SerializedPKRelatedField(
-        queryset=VLAN.objects.all(),
-        serializer=NestedVLANSerializer,
-        required=False,
-        many=True,
-    )
-    ip_addresses = SerializedPKRelatedField(
-        queryset=IPAddress.objects.all(),
-        serializer=NestedIPAddressSerializer,
-        required=False,
-        many=True,
-    )
-    parent_interface = NestedVMInterfaceSerializer(required=False, allow_null=True)
-    bridge = NestedVMInterfaceSerializer(required=False, allow_null=True)
+    mac_address = serializers.CharField(allow_blank=True, allow_null=True, required=False)
 
     class Meta:
         model = VMInterface
-        fields = [
-            "url",
-            "virtual_machine",
-            "name",
-            "status",
-            "enabled",
-            "parent_interface",
-            "bridge",
-            "mtu",
-            "mac_address",
-            "ip_addresses",
-            "description",
-            "mode",
-            "untagged_vlan",
-            "tagged_vlans",
-            "tags",
-        ]
+        fields = "__all__"
 
     def validate(self, data):
         # Validate many-to-many VLAN assignments

nautobot/virtualization/api/urls.py

@@ -1,4 +1,4 @@
-from nautobot.core.api import OrderedDefaultRouter
+from nautobot.core.api.routers import OrderedDefaultRouter
 from . import views