authentik.core.api.utils

  1"""API Utilities"""
  2
  3from typing import Any
  4
  5from django.db import models
  6from django.db.models import Model
  7from drf_spectacular.extensions import OpenApiSerializerFieldExtension
  8from drf_spectacular.plumbing import build_basic_type
  9from drf_spectacular.types import OpenApiTypes
 10from rest_framework.fields import (
 11    CharField,
 12    IntegerField,
 13    JSONField,
 14    SerializerMethodField,
 15)
 16from rest_framework.serializers import ModelSerializer as BaseModelSerializer
 17from rest_framework.serializers import (
 18    Serializer,
 19    ValidationError,
 20    model_meta,
 21    raise_errors_on_nested_writes,
 22)
 23
 24
 25def is_dict(value: Any):
 26    """Ensure a value is a dictionary, useful for JSONFields"""
 27    if isinstance(value, dict):
 28        return
 29    raise ValidationError("Value must be a dictionary, and not have any duplicate keys.")
 30
 31
 32class JSONDictField(JSONField):
 33    """JSON Field which only allows dictionaries"""
 34
 35    default_validators = [is_dict]
 36
 37
 38class JSONExtension(OpenApiSerializerFieldExtension):
 39    """Generate API Schema for JSON fields as"""
 40
 41    target_class = "authentik.core.api.utils.JSONDictField"
 42
 43    def map_serializer_field(self, auto_schema, direction):
 44        return build_basic_type(OpenApiTypes.OBJECT)
 45
 46
 47class ModelSerializer(BaseModelSerializer):
 48
 49    # By default, JSON fields we have are used to store dictionaries
 50    serializer_field_mapping = BaseModelSerializer.serializer_field_mapping.copy()
 51    serializer_field_mapping[models.JSONField] = JSONDictField
 52
 53    def update(self, instance: Model, validated_data):
 54        raise_errors_on_nested_writes("update", self, validated_data)
 55        info = model_meta.get_field_info(instance)
 56
 57        # Simply set each attribute on the instance, and then save it.
 58        # Note that unlike `.create()` we don't need to treat many-to-many
 59        # relationships as being a special case. During updates we already
 60        # have an instance pk for the relationships to be associated with.
 61        m2m_fields = []
 62        for attr, value in validated_data.items():
 63            if attr in info.relations and info.relations[attr].to_many:
 64                m2m_fields.append((attr, value))
 65            else:
 66                setattr(instance, attr, value)
 67
 68        instance.save()
 69
 70        # Note that many-to-many fields are set after updating instance.
 71        # Setting m2m fields triggers signals which could potentially change
 72        # updated instance and we do not want it to collide with .update()
 73        for attr, value in m2m_fields:
 74            field = getattr(instance, attr)
 75            # We can't check for inheritance here as m2m managers are generated dynamically
 76            if field.__class__.__name__ == "RelatedManager":
 77                field.set(value, bulk=False)
 78            else:
 79                field.set(value)
 80
 81        return instance
 82
 83
 84class PassiveSerializer(Serializer):
 85    """Base serializer class which doesn't implement create/update methods"""
 86
 87    def create(self, validated_data: dict) -> Model:  # pragma: no cover
 88        return Model()
 89
 90    def update(self, instance: Model, validated_data: dict) -> Model:  # pragma: no cover
 91        return Model()
 92
 93
 94class PropertyMappingPreviewSerializer(PassiveSerializer):
 95    """Preview how the current user is mapped via the property mappings selected in a provider"""
 96
 97    preview = JSONDictField(read_only=True)
 98
 99
100class MetaNameSerializer(PassiveSerializer):
101    """Add verbose names to response"""
102
103    verbose_name = SerializerMethodField()
104    verbose_name_plural = SerializerMethodField()
105    meta_model_name = SerializerMethodField()
106
107    def get_verbose_name(self, obj: Model) -> str:
108        """Return object's verbose_name"""
109        return obj._meta.verbose_name
110
111    def get_verbose_name_plural(self, obj: Model) -> str:
112        """Return object's plural verbose_name"""
113        return obj._meta.verbose_name_plural
114
115    def get_meta_model_name(self, obj: Model) -> str:
116        """Return internal model name"""
117        return f"{obj._meta.app_label}.{obj._meta.model_name}"
118
119
120class CacheSerializer(PassiveSerializer):
121    """Generic cache stats for an object"""
122
123    count = IntegerField(read_only=True)
124
125
126class LinkSerializer(PassiveSerializer):
127    """Returns a single link"""
128
129    link = CharField()
130
131
132class ThemedUrlsSerializer(PassiveSerializer):
133    """Themed URLs - maps theme names to URLs for light and dark themes"""
134
135    light = CharField(required=False, allow_null=True)
136    dark = CharField(required=False, allow_null=True)