authentik.stages.authenticator_static.api

AuthenticatorStaticStage API Views

 1"""AuthenticatorStaticStage API Views"""
 2
 3from rest_framework import mixins
 4from rest_framework.viewsets import GenericViewSet, ModelViewSet
 5
 6from authentik.core.api.groups import PartialUserSerializer
 7from authentik.core.api.used_by import UsedByMixin
 8from authentik.core.api.utils import ModelSerializer
 9from authentik.flows.api.stages import StageSerializer
10from authentik.stages.authenticator_static.models import (
11    AuthenticatorStaticStage,
12    StaticDevice,
13    StaticToken,
14)
15
16
17class AuthenticatorStaticStageSerializer(StageSerializer):
18    """AuthenticatorStaticStage Serializer"""
19
20    class Meta:
21        model = AuthenticatorStaticStage
22        fields = StageSerializer.Meta.fields + [
23            "configure_flow",
24            "friendly_name",
25            "token_count",
26            "token_length",
27        ]
28
29
30class AuthenticatorStaticStageViewSet(UsedByMixin, ModelViewSet):
31    """AuthenticatorStaticStage Viewset"""
32
33    queryset = AuthenticatorStaticStage.objects.all()
34    serializer_class = AuthenticatorStaticStageSerializer
35    filterset_fields = "__all__"
36    ordering = ["name"]
37    search_fields = ["name"]
38
39
40class StaticDeviceTokenSerializer(ModelSerializer):
41    """Serializer for static device's tokens"""
42
43    class Meta:
44        model = StaticToken
45        fields = ["token"]
46
47
48class StaticDeviceSerializer(ModelSerializer):
49    """Serializer for static authenticator devices"""
50
51    token_set = StaticDeviceTokenSerializer(many=True, read_only=True)
52    user = PartialUserSerializer(read_only=True)
53
54    class Meta:
55        model = StaticDevice
56        fields = ["name", "token_set", "pk", "user"]
57
58
59class StaticDeviceViewSet(
60    mixins.RetrieveModelMixin,
61    mixins.UpdateModelMixin,
62    mixins.DestroyModelMixin,
63    UsedByMixin,
64    mixins.ListModelMixin,
65    GenericViewSet,
66):
67    """Viewset for static authenticator devices"""
68
69    queryset = StaticDevice.objects.filter(confirmed=True)
70    serializer_class = StaticDeviceSerializer
71    search_fields = ["name"]
72    filterset_fields = ["name"]
73    ordering = ["name"]
74    owner_field = "user"
75
76
77class StaticAdminDeviceViewSet(ModelViewSet):
78    """Viewset for static authenticator devices (for admins)"""
79
80    queryset = StaticDevice.objects.all()
81    serializer_class = StaticDeviceSerializer
82    search_fields = ["name"]
83    filterset_fields = ["name"]
84    ordering = ["name"]
class AuthenticatorStaticStageSerializer(authentik.flows.api.stages.StageSerializer): 
18class AuthenticatorStaticStageSerializer(StageSerializer):
19    """AuthenticatorStaticStage Serializer"""
20
21    class Meta:
22        model = AuthenticatorStaticStage
23        fields = StageSerializer.Meta.fields + [
24            "configure_flow",
25            "friendly_name",
26            "token_count",
27            "token_length",
28        ]

AuthenticatorStaticStage Serializer

Inherited Members
authentik.flows.api.stages.StageSerializer
component
flow_set
to_representation
get_component
authentik.core.api.utils.ModelSerializer
serializer_field_mapping
update
authentik.core.api.utils.MetaNameSerializer
verbose_name
verbose_name_plural
meta_model_name
get_verbose_name
get_verbose_name_plural
get_meta_model_name
class AuthenticatorStaticStageSerializer.Meta: 
21    class Meta:
22        model = AuthenticatorStaticStage
23        fields = StageSerializer.Meta.fields + [
24            "configure_flow",
25            "friendly_name",
26            "token_count",
27            "token_length",
28        ]
fields = ['pk', 'name', 'component', 'verbose_name', 'verbose_name_plural', 'meta_model_name', 'flow_set', 'configure_flow', 'friendly_name', 'token_count', 'token_length']
class AuthenticatorStaticStageViewSet(authentik.core.api.used_by.UsedByMixin, rest_framework.viewsets.ModelViewSet): 
31class AuthenticatorStaticStageViewSet(UsedByMixin, ModelViewSet):
32    """AuthenticatorStaticStage Viewset"""
33
34    queryset = AuthenticatorStaticStage.objects.all()
35    serializer_class = AuthenticatorStaticStageSerializer
36    filterset_fields = "__all__"
37    ordering = ["name"]
38    search_fields = ["name"]

AuthenticatorStaticStage Viewset

queryset = <InheritanceQuerySet []>
serializer_class = <class 'AuthenticatorStaticStageSerializer'>
filterset_fields = '__all__'
ordering = ['name']
search_fields = ['name']
name = None
description = None
suffix = None
detail = None
basename = None
Inherited Members
authentik.core.api.used_by.UsedByMixin
used_by
class StaticDeviceTokenSerializer(authentik.core.api.utils.ModelSerializer): 
41class StaticDeviceTokenSerializer(ModelSerializer):
42    """Serializer for static device's tokens"""
43
44    class Meta:
45        model = StaticToken
46        fields = ["token"]

Serializer for static device's tokens

Inherited Members
authentik.core.api.utils.ModelSerializer
serializer_field_mapping
update
class StaticDeviceTokenSerializer.Meta: 
44    class Meta:
45        model = StaticToken
46        fields = ["token"]
fields = ['token']
class StaticDeviceSerializer(authentik.core.api.utils.ModelSerializer): 
49class StaticDeviceSerializer(ModelSerializer):
50    """Serializer for static authenticator devices"""
51
52    token_set = StaticDeviceTokenSerializer(many=True, read_only=True)
53    user = PartialUserSerializer(read_only=True)
54
55    class Meta:
56        model = StaticDevice
57        fields = ["name", "token_set", "pk", "user"]

Serializer for static authenticator devices

token_set
user
Inherited Members
authentik.core.api.utils.ModelSerializer
serializer_field_mapping
update
class StaticDeviceSerializer.Meta: 
55    class Meta:
56        model = StaticDevice
57        fields = ["name", "token_set", "pk", "user"]
fields = ['name', 'token_set', 'pk', 'user']
class StaticDeviceViewSet(rest_framework.mixins.RetrieveModelMixin, rest_framework.mixins.UpdateModelMixin, rest_framework.mixins.DestroyModelMixin, authentik.core.api.used_by.UsedByMixin, rest_framework.mixins.ListModelMixin, rest_framework.viewsets.GenericViewSet): 
60class StaticDeviceViewSet(
61    mixins.RetrieveModelMixin,
62    mixins.UpdateModelMixin,
63    mixins.DestroyModelMixin,
64    UsedByMixin,
65    mixins.ListModelMixin,
66    GenericViewSet,
67):
68    """Viewset for static authenticator devices"""
69
70    queryset = StaticDevice.objects.filter(confirmed=True)
71    serializer_class = StaticDeviceSerializer
72    search_fields = ["name"]
73    filterset_fields = ["name"]
74    ordering = ["name"]
75    owner_field = "user"

Viewset for static authenticator devices

queryset = <QuerySet []>
serializer_class = <class 'StaticDeviceSerializer'>
search_fields = ['name']
filterset_fields = ['name']
ordering = ['name']
owner_field = 'user'
name = None
description = None
suffix = None
detail = None
basename = None
Inherited Members
authentik.core.api.used_by.UsedByMixin
used_by
class StaticAdminDeviceViewSet(rest_framework.viewsets.ModelViewSet): 
78class StaticAdminDeviceViewSet(ModelViewSet):
79    """Viewset for static authenticator devices (for admins)"""
80
81    queryset = StaticDevice.objects.all()
82    serializer_class = StaticDeviceSerializer
83    search_fields = ["name"]
84    filterset_fields = ["name"]
85    ordering = ["name"]

Viewset for static authenticator devices (for admins)

queryset = <QuerySet []>
serializer_class = <class 'StaticDeviceSerializer'>
search_fields = ['name']
filterset_fields = ['name']
ordering = ['name']
name = None
description = None
suffix = None
detail = None
basename = None