class MappingVersionListSerializer(MappingListSerializer):
previous_version_url = CharField(read_only=True, source='prev_version_uri')
source_versions = ListField(read_only=True)
collection_versions = ListField(read_only=True)
class Meta:
model = Mapping
fields = MappingListSerializer.Meta.fields + (
'previous_version_url',
'source_versions',
'collection_versions',
)
def __init__(self, *args, **kwargs):
params = get(kwargs, 'context.request.query_params')
self.query_params = params.dict() if params else dict()
self.include_source_versions = self.query_params.get(
INCLUDE_SOURCE_VERSIONS) in ['true', True]
self.include_collection_versions = self.query_params.get(
INCLUDE_COLLECTION_VERSIONS) in ['true', True]
try:
if not self.include_source_versions:
self.fields.pop('source_versions', None)
if not self.include_collection_versions:
self.fields.pop('collection_versions', None)
except: # pylint: disable=bare-except
pass
super().__init__(*args, **kwargs)
class ConfigSerializer(PassiveSerializer):
"""Serialize authentik Config into DRF Object"""
branding_logo = CharField(read_only=True)
branding_title = CharField(read_only=True)
ui_footer_links = ListField(child=FooterLinkSerializer(), read_only=True)
error_reporting_enabled = BooleanField(read_only=True)
error_reporting_environment = CharField(read_only=True)
error_reporting_send_pii = BooleanField(read_only=True)
capabilities = ListField(child=ChoiceField(choices=Capabilities.choices))
class MappingVersionDetailSerializer(MappingDetailSerializer):
previous_version_url = CharField(read_only=True, source='prev_version_uri')
source_versions = ListField(read_only=True)
collection_versions = ListField(read_only=True)
class Meta:
model = Mapping
fields = MappingDetailSerializer.Meta.fields + (
'previous_version_url',
'source_versions',
'collection_versions',
)
class OpenIDConnectConfigurationSerializer(PassiveSerializer):
"""rest_framework Serializer for OIDC Configuration"""
issuer = CharField()
authorization_endpoint = CharField()
token_endpoint = CharField()
userinfo_endpoint = CharField()
end_session_endpoint = CharField()
introspection_endpoint = CharField()
jwks_uri = CharField()
response_types_supported = ListField(child=CharField())
id_token_signing_alg_values_supported = ListField(child=CharField())
subject_types_supported = ListField(child=CharField())
token_endpoint_auth_methods_supported = ListField(child=CharField())
def validate_data_list(self, data):
ListField().run_validation(data)
model = self.parent.Meta.model
rel = getattr(model, self.field_name).rel
if isinstance(rel, ManyToOneRel):
# ManyToOne Relation
field_name = getattr(model, self.field_name).field.name
# remove field_name to validated fields
contain_field = lambda a: a != field_name
fields = filter(contain_field, serializer_class.Meta.fields)
original_fields = copy.copy(serializer_class.Meta.fields)
serializer_class.Meta.fields = list(fields)
parent_serializer = serializer_class(
**self.child.validation_kwargs,
data=data,
many=True,
partial=self.is_partial,
context=self.context)
parent_serializer.is_valid(raise_exception=True)
serializer_class.Meta.fields = original_fields
else:
# ManyToMany Relation
parent_serializer = serializer_class(
**self.child.validation_kwargs,
data=data,
many=True,
partial=self.is_partial,
context=self.context)
parent_serializer.is_valid(raise_exception=True)
return parent_serializer.validated_data
class SourceDetailSerializer(SourceCreateOrUpdateSerializer):
type = CharField(source='resource_type')
uuid = CharField(source='id')
id = CharField(source='mnemonic')
short_code = CharField(source='mnemonic')
owner = CharField(source='parent_resource')
owner_type = CharField(source='parent_resource_type')
owner_url = CharField(source='parent_url')
versions = IntegerField(source='num_versions')
created_on = DateTimeField(source='created_at')
updated_on = DateTimeField(source='updated_at')
supported_locales = ListField(required=False, allow_empty=True)
created_by = CharField(source='created_by.username', read_only=True)
updated_by = DateTimeField(source='updated_by.username', read_only=True)
class Meta:
model = Source
lookup_field = 'mnemonic'
fields = ('type', 'uuid', 'id', 'short_code', 'name', 'full_name',
'description', 'source_type', 'custom_validation_schema',
'public_access', 'default_locale', 'supported_locales',
'website', 'url', 'owner', 'owner_type', 'owner_url',
'versions', 'created_on', 'updated_on', 'created_by',
'updated_by', 'extras', 'external_id', 'versions_url',
'version', 'concepts_url', 'mappings_url', 'active_concepts',
'active_mappings')
class BaseMessageSerializer(serializers.ModelSerializer):
class Meta:
model = Message
read_only_fields = (
"resource_uri",
"message_id",
"subject",
"date",
"sender",
"recipients",
)
fields = read_only_fields + ("tags",)
resource_uri = HyperlinkedMessageField(view_name="messages-detail")
recipients = AddressSerializer(many=True)
sender = AddressSerializer()
tags = ListField(child=CharField(), required=False)
def create(self, validated_data):
validated_data["recipients"] = self.fields["recipients"].create(
validated_data["recipients"]
)
validated_data["sender"] = self.fields["sender"].create(
validated_data["sender"]
)
if "project" in validated_data:
project = validated_data.pop("project")
return Message.objects.create(project=project, **validated_data)
return Message.objects.create(project=self.context["project"], **validated_data)
def run_data_list_validation(self, data, partial=None):
ListField().run_validation(data)
model = self.parent.Meta.model
rel = getattr(model, self.source).rel
if isinstance(rel, ManyToOneRel):
# ManyToOne Relation
field_name = getattr(model, self.source).field.name
child_serializer = serializer_class(
**self.child.validation_kwargs,
data=data,
many=True,
partial=partial,
context=self.context
)
# Remove parent field(field_name) for validation purpose
child_serializer.child.fields.pop(field_name, None)
# Check if a serializer is valid
child_serializer.is_valid(raise_exception=True)
else:
# ManyToMany Relation
child_serializer = serializer_class(
**self.child.validation_kwargs,
data=data,
many=True,
partial=partial,
context=self.context
)
# Check if a serializer is valid
child_serializer.is_valid(raise_exception=True)
class ContactInfoSerializer(EmbeddedDocumentSerializer):
address = CharField(required=False, allow_null=True, allow_blank=True)
code_postal = CharField(required=False, allow_null=True, allow_blank=True)
email = CharField(required=False, allow_null=True, allow_blank=True)
phone_numbers = ListField(child=CharField(allow_blank=True),
allow_null=True,
required=False)
country = BReferenceField(serializer=CountrySerializer,
read_only=False,
required=False,
allow_null=True)
city = BReferenceField(serializer=CitySerializer,
read_only=False,
required=False,
allow_null=True)
province = BReferenceField(serializer=ProvinceSerializer,
read_only=False,
required=False,
allow_null=True)
class Meta:
model = ContactInfo
fields = ("address", "code_postal", "email", "phone_numbers",
"country", "city", "province")
class PollConfigSerializer(Serializer):
equal_width = BooleanField(default=False)
title = CharField()
options = ListField(child=CharField(), allow_empty=False)
lifetime = ChoiceField(choices=_PollLifetime.CHOICES,
default=_PollLifetime.MONTH)
def create(self, validated_data):
poll_expires_at = timezone.now() + _PollLifetime.to_relativedelta(
validated_data['lifetime'])
poll_equal_width = validated_data['equal_width']
poll_title = safe_html(validated_data['title'])
poll_option_names = [
safe_html(str(option_name))
for option_name in validated_data['options']
]
with transaction.atomic():
poll = Poll.objects.create(title=poll_title,
expires_at=poll_expires_at,
equal_width=poll_equal_width)
for i, option_name in enumerate(poll_option_names):
PollOption.objects.create(poll=poll,
position=i,
name=option_name)
return poll
class TaskSerializer(PassiveSerializer):
"""Serialize TaskInfo and TaskResult"""
task_name = CharField()
task_description = CharField()
task_finish_timestamp = DateTimeField(source="finish_time")
status = ChoiceField(
source="result.status.name",
choices=[(x.name, x.name) for x in TaskResultStatus],
)
messages = ListField(source="result.messages")
def to_representation(self, instance):
"""When a new version of authentik adds fields to TaskInfo,
the API will fail with an AttributeError, as the classes
are pickled in cache. In that case, just delete the info"""
try:
return super().to_representation(instance)
except AttributeError: # pragma: no cover
if isinstance(self.instance, list):
for inst in self.instance:
inst.delete()
else:
self.instance.delete()
return {}
class SourceVersionDetailSerializer(SourceCreateOrUpdateSerializer):
type = CharField(source='resource_type')
uuid = CharField(source='id')
id = CharField(source='version')
short_code = CharField(source='mnemonic')
owner = CharField(source='parent_resource')
owner_type = CharField(source='parent_resource_type')
owner_url = CharField(source='parent_url')
created_on = DateTimeField(source='created_at')
updated_on = DateTimeField(source='updated_at')
created_by = CharField(source='created_by.username', read_only=True)
updated_by = DateTimeField(source='updated_by.username', read_only=True)
supported_locales = ListField(required=False, allow_empty=True)
is_processing = BooleanField(read_only=True)
released = BooleanField(default=False)
version_url = CharField(source='uri')
url = CharField(source='versioned_object_url')
previous_version_url = CharField(source='prev_version_uri')
summary = SerializerMethodField()
class Meta:
model = Source
lookup_field = 'mnemonic'
fields = ('type', 'uuid', 'id', 'short_code', 'name', 'full_name',
'description', 'source_type', 'custom_validation_schema',
'public_access', 'default_locale', 'supported_locales',
'website', 'url', 'owner', 'owner_type', 'owner_url',
'retired', 'version_url', 'previous_version_url',
'created_on', 'updated_on', 'created_by', 'updated_by',
'extras', 'external_id', 'version', 'concepts_url',
'mappings_url', 'is_processing', 'released', 'canonical_url',
'identifier', 'publisher', 'contact', 'jurisdiction',
'purpose', 'copyright', 'content_type', 'revision_date',
'summary', 'text')
def __init__(self, *args, **kwargs):
params = get(kwargs, 'context.request.query_params')
self.include_summary = False
if params:
self.query_params = params.dict()
self.include_summary = self.query_params.get(INCLUDE_SUMMARY) in [
'true', True
]
try:
if not self.include_summary:
self.fields.pop('summary', None)
except: # pylint: disable=bare-except
pass
super().__init__(*args, **kwargs)
def get_summary(self, obj):
summary = None
if self.include_summary:
summary = SourceVersionSummarySerializer(obj).data
return summary
class PaginationNamespaceSerializer(EmbeddedDocumentSerializer):
name = CharField()
page_size = IntegerField()
page_options = ListField(child=IntegerField(), required=False, default=[5, 10, 15, 20])
class Meta:
model = PaginationNamespace
fields = ('name', 'page_size', 'page_options')
def run_pk_list_validation(self, pks):
ListField().run_validation(pks)
queryset = self.child.Meta.model.objects.all()
PrimaryKeyRelatedField(
**self.child.validation_kwargs,
queryset=queryset,
many=True
).run_validation(pks)
class UploadeBaseSerializer(serializers.Serializer):
property_service = PropertyService()
propertyId = IntegerField(min_value=1, required=True)
modelName = CharField(min_length=2, required=True)
image = ListField(child=FileField(), required=True)
def create(self, validated_data):
return self.property_service.upload_image(validated_data=validated_data)
class CategorySerializer(ModelSerializer):
parent = ListField(read_only=True,
source='get_ancestors',
child=RecursiveField())
class Meta:
model = Category
fields = ['id', 'title', 'parent']
def validate_pk_list(self, pks):
ListField().run_validation(pks)
queryset = self.child.Meta.model.objects.all()
validator = PrimaryKeyRelatedField(
queryset=queryset,
many=True
)
return validator.run_validation(pks)
class sanlp(models.Model):
p_id=models.CharField(max_length=50)
p_name=models.CharField(max_length=500)
review_detail=ListField()
def __str__(self):
return self.p_name
class SharedGroupSerializer(EmbeddedDocumentSerializer):
user = BDynamicField()
access = ListField(child=CharField())
is_owner = BooleanField(default=False)
class Meta:
model = SharedGroup
fields = '__all__'
class ConfigSerializer(PassiveSerializer):
"""Serialize authentik Config into DRF Object"""
error_reporting_enabled = BooleanField(read_only=True)
error_reporting_environment = CharField(read_only=True)
error_reporting_send_pii = BooleanField(read_only=True)
capabilities = ListField(child=ChoiceField(choices=Capabilities.choices))
class ProcedureCatalogSerializer(DocumentSerializer):
is_default = BooleanField(default=False)
procedures = ListField(child=BReferenceField(serializer=ProcedureSerializer, required=False, allow_null=True),
required=False,
allow_null=True)
class Meta:
model = ProcedureCatalog
fields = ("id", "name", "is_default", "procedures")
class CollectionVersionDetailSerializer(CollectionCreateOrUpdateSerializer):
type = CharField(source='resource_type')
uuid = CharField(source='id')
id = CharField(source='version')
short_code = CharField(source='mnemonic')
owner = CharField(source='parent_resource')
owner_type = CharField(source='parent_resource_type')
owner_url = CharField(source='parent_url')
versions = IntegerField(source='num_versions')
created_on = DateTimeField(source='created_at')
updated_on = DateTimeField(source='updated_at')
supported_locales = ListField(required=False, allow_empty=True)
is_processing = BooleanField(read_only=True)
version_url = CharField(source='uri')
url = CharField(source='versioned_object_url')
previous_version_url = CharField(source='prev_version_uri')
class Meta:
model = Collection
lookup_field = 'mnemonic'
fields = (
'type',
'uuid',
'id',
'short_code',
'name',
'full_name',
'description',
'collection_type',
'custom_validation_schema',
'public_access',
'default_locale',
'supported_locales',
'website',
'url',
'owner',
'owner_type',
'owner_url',
'versions',
'version_url',
'previous_version_url',
'created_on',
'updated_on',
'created_by',
'updated_by',
'extras',
'external_id',
'version',
'version',
'concepts_url',
'mappings_url',
'is_processing',
'canonical_url',
'released',
'retired',
)
class PostCreateSerializer(serializers.ModelSerializer):
address = AddressSerializer(read_only=True)
salesForm = SalesFormSerializer(read_only=True)
management_set = ListField()
option_set = ListField()
securitySafety_set = ListField()
postimage = serializers.ImageField(use_url=True)
class Meta:
model = PostRoom
fields = [
'pk',
'broker',
'type',
'description',
'salesForm',
'floor',
'totalFloor',
'areaChar',
'supplyAreaInt',
'supplyAreaChar',
'shortRent',
'management_set',
'parkingDetail',
'parkingTF',
'living_expenses',
'living_expenses_detail',
'moveInChar',
'moveInDate',
'option_set',
'heatingType',
'pet',
'elevator',
'builtIn',
'veranda',
'depositLoan',
'totalCitizen',
'totalPark',
'complete',
'securitySafety_set',
'address',
'postimage',
]
class ConfigSerializer(PassiveSerializer):
"""Serialize authentik Config into DRF Object"""
error_reporting = ErrorReportingConfigSerializer(required=True)
capabilities = ListField(child=ChoiceField(choices=Capabilities.choices))
cache_timeout = IntegerField(required=True)
cache_timeout_flows = IntegerField(required=True)
cache_timeout_policies = IntegerField(required=True)
cache_timeout_reputation = IntegerField(required=True)
class ProductStatSerializer(Serializer):
"""
Not combined to a specific model
Read only, no create or update
"""
stats = DictField(
child=ListField(
child=IntegerField(),
)
)
class NotificationTransportTestSerializer(Serializer):
"""Notification test serializer"""
messages = ListField(child=CharField())
def create(self, request: Request) -> Response:
raise NotImplementedError
def update(self, request: Request) -> Response:
raise NotImplementedError
class SourceCreateSerializer(SourceCreateOrUpdateSerializer):
type = CharField(source='resource_type', read_only=True)
uuid = CharField(source='id', read_only=True)
id = CharField(required=True,
validators=[RegexValidator(regex=NAMESPACE_REGEX)],
source='mnemonic')
short_code = CharField(source='mnemonic', read_only=True)
name = CharField(required=True)
full_name = CharField(required=False)
description = CharField(required=False, allow_blank=True)
source_type = CharField(required=False, allow_blank=True)
custom_validation_schema = CharField(required=False,
allow_blank=True,
allow_null=True)
public_access = ChoiceField(required=False, choices=ACCESS_TYPE_CHOICES)
default_locale = CharField(required=False, allow_blank=True)
supported_locales = ListField(required=False, allow_empty=True)
website = CharField(required=False, allow_blank=True)
url = CharField(read_only=True)
canonical_url = CharField(required=False,
allow_null=True,
allow_blank=True)
versions_url = CharField(read_only=True)
concepts_url = CharField(read_only=True)
mappings_url = CharField(read_only=True)
owner = CharField(source='parent_resource', read_only=True)
owner_type = CharField(source='parent_resource_type', read_only=True)
owner_url = CharField(source='parent_url', read_only=True)
versions = IntegerField(source='num_versions', read_only=True)
created_on = DateTimeField(source='created_at', read_only=True)
updated_on = DateTimeField(source='updated_at', read_only=True)
created_by = CharField(source='owner', read_only=True)
updated_by = CharField(read_only=True)
extras = JSONField(required=False, allow_null=True)
external_id = CharField(required=False, allow_blank=True)
user_id = PrimaryKeyRelatedField(required=False,
queryset=UserProfile.objects.all(),
allow_null=True)
organization_id = PrimaryKeyRelatedField(
required=False, queryset=Organization.objects.all(), allow_null=True)
version = CharField(default=HEAD)
def create(self, validated_data):
source = self.prepare_object(validated_data)
user = self.context['request'].user
errors = Source.persist_new(source, user)
self._errors.update(errors)
return source
def create_version(self, validated_data):
source = self.prepare_object(validated_data)
user = self.context['request'].user
errors = Source.persist_new_version(source, user)
self._errors.update(errors)
return source
class SeriesSerializer(BaseMessageSerializer):
class Meta:
model = Message
subclass_read_only_fields = (
"message",
"stripped_subject",
"num_patches",
"total_patches",
"results",
"mbox_uri",
)
fields = (
BaseMessageSerializer.Meta.fields
+ subclass_read_only_fields
+ (
"last_comment_date",
"last_reply_date",
"is_complete",
"is_merged",
"is_obsolete",
"is_tested",
"is_reviewed",
"maintainers",
)
)
read_only_fields = (
BaseMessageSerializer.Meta.read_only_fields + subclass_read_only_fields
)
resource_uri = HyperlinkedMessageField(view_name="series-detail")
mbox_uri = HyperlinkedMessageField(view_name="series-mbox")
message = HyperlinkedMessageField(view_name="messages-detail")
results = HyperlinkedMessageField(
view_name="results-list", lookup_field="series_message_id"
)
total_patches = SerializerMethodField()
maintainers = ListField(child=CharField(), required=False)
def __init__(self, *args, **kwargs):
self.detailed = kwargs.pop("detailed", False)
super(SeriesSerializer, self).__init__(*args, **kwargs)
def get_fields(self):
fields = super(SeriesSerializer, self).get_fields()
request = self.context["request"]
dispatch_module_hook(
"rest_series_fields_hook",
request=request,
fields=fields,
detailed=self.detailed,
)
return fields
def get_total_patches(self, obj):
return obj.get_total_patches()
class TableViewSerializer(EmbeddedDocumentSerializer):
shared_group = BEmbeddedListField(serializer=SharedGroupSerializer)
name = CharField(required=True)
model = CharField(required=True)
is_default = BooleanField(default=False)
access = ChoiceField(choices=['private', 'public', 'restrict'], required=False)
query = ListField(child=ViewQuerySerializer(many=False, read_only=False, allow_null=True, required=False))
class Meta:
model = TableView
fields = '__all__'
class ExpiringBaseGrantModelSerializer(ModelSerializer, MetaNameSerializer):
"""Serializer for BaseGrantModel and ExpiringBaseGrant"""
user = UserSerializer()
provider = OAuth2ProviderSerializer()
scope = ListField(child=CharField())
class Meta:
model = AuthorizationCode
fields = ["pk", "provider", "user", "is_expired", "expires", "scope"]
depth = 2
