authentik.policies.reputation.api

Reputation policy API Views

 1"""Reputation policy API Views"""
 2
 3from django.utils.translation import gettext_lazy as _
 4from django_filters.filters import BaseInFilter, CharFilter
 5from django_filters.filterset import FilterSet
 6from rest_framework import mixins
 7from rest_framework.exceptions import ValidationError
 8from rest_framework.viewsets import GenericViewSet, ModelViewSet
 9
10from authentik.core.api.used_by import UsedByMixin
11from authentik.core.api.utils import ModelSerializer
12from authentik.policies.api.policies import PolicySerializer
13from authentik.policies.reputation.models import Reputation, ReputationPolicy
14
15
16class CharInFilter(BaseInFilter, CharFilter):
17    pass
18
19
20class ReputationPolicySerializer(PolicySerializer):
21    """Reputation Policy Serializer"""
22
23    def validate(self, attrs: dict) -> dict:
24        if not attrs.get("check_ip", False) and not attrs.get("check_username", False):
25            raise ValidationError(_("Either IP or Username must be checked"))
26        return super().validate(attrs)
27
28    class Meta:
29        model = ReputationPolicy
30        fields = PolicySerializer.Meta.fields + [
31            "check_ip",
32            "check_username",
33            "threshold",
34        ]
35
36
37class ReputationPolicyViewSet(UsedByMixin, ModelViewSet):
38    """Reputation Policy Viewset"""
39
40    queryset = ReputationPolicy.objects.all()
41    serializer_class = ReputationPolicySerializer
42    filterset_fields = "__all__"
43    search_fields = ["name", "threshold"]
44    ordering = ["name"]
45
46
47class ReputationFilter(FilterSet):
48    """Filter for reputation"""
49
50    identifier_in = CharInFilter(field_name="identifier", lookup_expr="in")
51
52    class Meta:
53        model = Reputation
54        fields = ["identifier", "ip", "score"]
55
56
57class ReputationSerializer(ModelSerializer):
58    """Reputation Serializer"""
59
60    class Meta:
61        model = Reputation
62        fields = [
63            "pk",
64            "identifier",
65            "ip",
66            "ip_geo_data",
67            "ip_asn_data",
68            "score",
69            "updated",
70        ]
71
72
73class ReputationViewSet(
74    mixins.RetrieveModelMixin,
75    mixins.DestroyModelMixin,
76    UsedByMixin,
77    mixins.ListModelMixin,
78    GenericViewSet,
79):
80    """Reputation Viewset"""
81
82    queryset = Reputation.objects.including_expired().all()
83    serializer_class = ReputationSerializer
84    search_fields = ["identifier", "ip", "score"]
85    filterset_class = ReputationFilter
86    ordering = ["ip"]
class CharInFilter(django_filters.filters.BaseInFilter, django_filters.filters.CharFilter): 
17class CharInFilter(BaseInFilter, CharFilter):
18    pass

Base class for CSV type filters, such as IN and RANGE.

class ReputationPolicySerializer(authentik.policies.api.policies.PolicySerializer): 
21class ReputationPolicySerializer(PolicySerializer):
22    """Reputation Policy Serializer"""
23
24    def validate(self, attrs: dict) -> dict:
25        if not attrs.get("check_ip", False) and not attrs.get("check_username", False):
26            raise ValidationError(_("Either IP or Username must be checked"))
27        return super().validate(attrs)
28
29    class Meta:
30        model = ReputationPolicy
31        fields = PolicySerializer.Meta.fields + [
32            "check_ip",
33            "check_username",
34            "threshold",
35        ]

Reputation Policy Serializer

def validate(self, attrs: dict) -> dict: 
24    def validate(self, attrs: dict) -> dict:
25        if not attrs.get("check_ip", False) and not attrs.get("check_username", False):
26            raise ValidationError(_("Either IP or Username must be checked"))
27        return super().validate(attrs)
Inherited Members
authentik.policies.api.policies.PolicySerializer
PolicySerializer
component
bound_to
get_component
get_bound_to
to_representation
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 ReputationPolicySerializer.Meta: 
29    class Meta:
30        model = ReputationPolicy
31        fields = PolicySerializer.Meta.fields + [
32            "check_ip",
33            "check_username",
34            "threshold",
35        ]
fields = ['pk', 'name', 'execution_logging', 'component', 'verbose_name', 'verbose_name_plural', 'meta_model_name', 'bound_to', 'check_ip', 'check_username', 'threshold']
class ReputationPolicyViewSet(authentik.core.api.used_by.UsedByMixin, rest_framework.viewsets.ModelViewSet): 
38class ReputationPolicyViewSet(UsedByMixin, ModelViewSet):
39    """Reputation Policy Viewset"""
40
41    queryset = ReputationPolicy.objects.all()
42    serializer_class = ReputationPolicySerializer
43    filterset_fields = "__all__"
44    search_fields = ["name", "threshold"]
45    ordering = ["name"]

Reputation Policy Viewset

queryset = <InheritanceQuerySet []>
serializer_class = <class 'ReputationPolicySerializer'>
filterset_fields = '__all__'
search_fields = ['name', 'threshold']
ordering = ['name']
name = None
description = None
suffix = None
detail = None
basename = None
Inherited Members
authentik.core.api.used_by.UsedByMixin
used_by
class ReputationFilter(django_filters.filterset.FilterSet): 
48class ReputationFilter(FilterSet):
49    """Filter for reputation"""
50
51    identifier_in = CharInFilter(field_name="identifier", lookup_expr="in")
52
53    class Meta:
54        model = Reputation
55        fields = ["identifier", "ip", "score"]

Filter for reputation

identifier_in
declared_filters = OrderedDict({'identifier_in': <CharInFilter object>})
base_filters = OrderedDict({'identifier': <django_filters.filters.CharFilter object>, 'ip': <django_filters.filters.CharFilter object>, 'score': <django_filters.filters.NumberFilter object>, 'identifier_in': <CharInFilter object>})
class ReputationFilter.Meta: 
53    class Meta:
54        model = Reputation
55        fields = ["identifier", "ip", "score"]
fields = ['identifier', 'ip', 'score']
class ReputationSerializer(authentik.core.api.utils.ModelSerializer): 
58class ReputationSerializer(ModelSerializer):
59    """Reputation Serializer"""
60
61    class Meta:
62        model = Reputation
63        fields = [
64            "pk",
65            "identifier",
66            "ip",
67            "ip_geo_data",
68            "ip_asn_data",
69            "score",
70            "updated",
71        ]

Reputation Serializer

Inherited Members
authentik.core.api.utils.ModelSerializer
serializer_field_mapping
update
class ReputationSerializer.Meta: 
61    class Meta:
62        model = Reputation
63        fields = [
64            "pk",
65            "identifier",
66            "ip",
67            "ip_geo_data",
68            "ip_asn_data",
69            "score",
70            "updated",
71        ]
fields = ['pk', 'identifier', 'ip', 'ip_geo_data', 'ip_asn_data', 'score', 'updated']
class ReputationViewSet(rest_framework.mixins.RetrieveModelMixin, rest_framework.mixins.DestroyModelMixin, authentik.core.api.used_by.UsedByMixin, rest_framework.mixins.ListModelMixin, rest_framework.viewsets.GenericViewSet): 
74class ReputationViewSet(
75    mixins.RetrieveModelMixin,
76    mixins.DestroyModelMixin,
77    UsedByMixin,
78    mixins.ListModelMixin,
79    GenericViewSet,
80):
81    """Reputation Viewset"""
82
83    queryset = Reputation.objects.including_expired().all()
84    serializer_class = ReputationSerializer
85    search_fields = ["identifier", "ip", "score"]
86    filterset_class = ReputationFilter
87    ordering = ["ip"]

Reputation Viewset

queryset = <QuerySet []>
serializer_class = <class 'ReputationSerializer'>
search_fields = ['identifier', 'ip', 'score']
filterset_class = <class 'ReputationFilter'>
ordering = ['ip']
name = None
description = None
suffix = None
detail = None
basename = None
Inherited Members
authentik.core.api.used_by.UsedByMixin
used_by