authentik.brands.api

  1"""Serializer for brands models"""
  2
  3from typing import Any
  4
  5from django.db import models
  6from drf_spectacular.utils import extend_schema, extend_schema_field
  7from rest_framework.decorators import action
  8from rest_framework.exceptions import ValidationError
  9from rest_framework.fields import (
 10    CharField,
 11    ChoiceField,
 12    ListField,
 13    SerializerMethodField,
 14)
 15from rest_framework.filters import OrderingFilter, SearchFilter
 16from rest_framework.permissions import AllowAny
 17from rest_framework.request import Request
 18from rest_framework.response import Response
 19from rest_framework.validators import UniqueValidator
 20from rest_framework.viewsets import ModelViewSet
 21
 22from authentik.brands.models import Brand
 23from authentik.core.api.used_by import UsedByMixin
 24from authentik.core.api.utils import ModelSerializer, PassiveSerializer, ThemedUrlsSerializer
 25from authentik.rbac.filters import SecretKeyFilter
 26from authentik.tenants.api.settings import FlagJSONField
 27from authentik.tenants.flags import Flag
 28from authentik.tenants.utils import get_current_tenant
 29
 30
 31class FooterLinkSerializer(PassiveSerializer):
 32    """Links returned in Config API"""
 33
 34    href = CharField(read_only=True, allow_null=True)
 35    name = CharField(read_only=True)
 36
 37
 38class BrandSerializer(ModelSerializer):
 39    """Brand Serializer"""
 40
 41    def validate(self, attrs: dict[str, Any]) -> dict[str, Any]:
 42        if attrs.get("default", False):
 43            brands = Brand.objects.filter(default=True)
 44            if self.instance:
 45                brands = brands.exclude(pk=self.instance.pk)
 46            if brands.exists():
 47                raise ValidationError({"default": "Only a single brand can be set as default."})
 48        return super().validate(attrs)
 49
 50    class Meta:
 51        model = Brand
 52        fields = [
 53            "brand_uuid",
 54            "domain",
 55            "default",
 56            "branding_title",
 57            "branding_logo",
 58            "branding_favicon",
 59            "branding_custom_css",
 60            "branding_default_flow_background",
 61            "flow_authentication",
 62            "flow_invalidation",
 63            "flow_recovery",
 64            "flow_unenrollment",
 65            "flow_user_settings",
 66            "flow_device_code",
 67            "default_application",
 68            "web_certificate",
 69            "client_certificates",
 70            "attributes",
 71        ]
 72        extra_kwargs = {
 73            # TODO: This field isn't unique on the database which is hard to backport
 74            # hence we just validate the uniqueness here
 75            "domain": {"validators": [UniqueValidator(Brand.objects.all())]},
 76        }
 77
 78
 79class Themes(models.TextChoices):
 80    """Themes"""
 81
 82    AUTOMATIC = "automatic"
 83    LIGHT = "light"
 84    DARK = "dark"
 85
 86
 87def get_default_ui_footer_links():
 88    """Get default UI footer links based on current tenant settings"""
 89    return get_current_tenant().footer_links
 90
 91
 92class CurrentBrandSerializer(PassiveSerializer):
 93    """Partial brand information for styling"""
 94
 95    matched_domain = CharField(source="domain")
 96    branding_title = CharField()
 97    branding_logo = CharField(source="branding_logo_url")
 98    branding_logo_themed_urls = ThemedUrlsSerializer(read_only=True, allow_null=True)
 99    branding_favicon = CharField(source="branding_favicon_url")
100    branding_favicon_themed_urls = ThemedUrlsSerializer(read_only=True, allow_null=True)
101    branding_custom_css = CharField()
102    ui_footer_links = ListField(
103        child=FooterLinkSerializer(),
104        read_only=True,
105        default=get_default_ui_footer_links,
106    )
107    ui_theme = ChoiceField(
108        choices=Themes.choices,
109        source="attributes.settings.theme.base",
110        default=Themes.AUTOMATIC,
111        read_only=True,
112    )
113
114    flow_authentication = CharField(source="flow_authentication.slug", required=False)
115    flow_invalidation = CharField(source="flow_invalidation.slug", required=False)
116    flow_recovery = CharField(source="flow_recovery.slug", required=False)
117    flow_unenrollment = CharField(source="flow_unenrollment.slug", required=False)
118    flow_user_settings = CharField(source="flow_user_settings.slug", required=False)
119    flow_device_code = CharField(source="flow_device_code.slug", required=False)
120
121    default_locale = CharField(read_only=True)
122    flags = SerializerMethodField()
123
124    @extend_schema_field(field=FlagJSONField)
125    def get_flags(self, _):
126        values = {}
127        for flag in Flag.available(visibility="public"):
128            values[flag().key] = flag.get()
129        return values
130
131
132class BrandViewSet(UsedByMixin, ModelViewSet):
133    """Brand Viewset"""
134
135    queryset = Brand.objects.all()
136    serializer_class = BrandSerializer
137    search_fields = [
138        "domain",
139        "branding_title",
140        "web_certificate__name",
141        "client_certificates__name",
142    ]
143    filterset_fields = [
144        "brand_uuid",
145        "domain",
146        "default",
147        "branding_title",
148        "branding_logo",
149        "branding_favicon",
150        "branding_default_flow_background",
151        "flow_authentication",
152        "flow_invalidation",
153        "flow_recovery",
154        "flow_unenrollment",
155        "flow_user_settings",
156        "flow_device_code",
157        "web_certificate",
158        "client_certificates",
159    ]
160    ordering = ["domain"]
161
162    filter_backends = [SecretKeyFilter, OrderingFilter, SearchFilter]
163
164    @extend_schema(
165        responses=CurrentBrandSerializer(many=False),
166    )
167    @action(methods=["GET"], detail=False, permission_classes=[AllowAny])
168    def current(self, request: Request) -> Response:
169        """Get current brand"""
170        brand: Brand = request._request.brand
171        return Response(CurrentBrandSerializer(brand, context={"request": request}).data)