class ErrorReportingConfigSerializer(PassiveSerializer):
"""Config for error reporting"""
enabled = BooleanField(read_only=True)
environment = CharField(read_only=True)
send_pii = BooleanField(read_only=True)
traces_sample_rate = FloatField(read_only=True)
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')
versions = IntegerField(source='num_versions')
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')
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',
'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',
'released',
)
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 ProductSerializer(Serializer):
id = IntegerField()
name = CharField()
surname = CharField()
price = IntegerField()
checked = BooleanField(default=False)
selected = BooleanField(default=False)
deleted = BooleanField(default=False)
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 SushiCredentialsSerializer(ModelSerializer):
organization = OrganizationSerializer(read_only=True)
platform = PlatformSerializer(read_only=True)
active_counter_reports_long = \
CounterReportTypeSerializer(many=True, source='active_counter_reports', read_only=True)
organization_id = PrimaryKeyRelatedField(
source='organization',
write_only=True,
queryset=Organization.objects.all())
platform_id = PrimaryKeyRelatedField(source='platform',
write_only=True,
queryset=Platform.objects.all())
locked_for_me = BooleanField(read_only=True)
can_lock = BooleanField(read_only=True)
submitter = HiddenField(default=CurrentUserDefault())
locked = SerializerMethodField()
class Meta:
model = SushiCredentials
fields = ('pk', 'organization', 'platform', 'enabled', 'url',
'counter_version', 'requestor_id', 'customer_id',
'http_username', 'http_password', 'api_key', 'extra_params',
'active_counter_reports', 'active_counter_reports_long',
'organization_id', 'platform_id', 'submitter',
'locked_for_me', 'lock_level', 'can_lock', 'locked',
'outside_consortium')
def get_locked(self, obj: SushiCredentials):
return obj.lock_level >= UL_CONS_STAFF
def update(self, instance: SushiCredentials, validated_data):
submitter = validated_data.pop('submitter',
None) or self.context['request'].user
if not instance.can_edit(submitter):
raise PermissionDenied(
'User is not allowed to edit this object - it is locked.')
result = super().update(instance,
validated_data) # type: SushiCredentials
result.last_updated_by = submitter
result.save()
submitter_level = submitter.organization_relationship(
result.organization_id)
result.can_lock = submitter_level >= UL_CONS_STAFF
result.locked_for_me = submitter_level < result.lock_level
return result
def create(self, validated_data):
submitter = validated_data.pop('submitter')
result = super().create(validated_data)
result.last_updated_by = submitter
result.save()
submitter_level = submitter.organization_relationship(
result.organization_id)
result.can_lock = submitter_level >= UL_CONS_STAFF
result.locked_for_me = submitter_level < result.lock_level
return result
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)
class OrganizationSerializer(ModelSerializer):
is_admin = BooleanField(read_only=True)
is_member = BooleanField(read_only=True)
class Meta:
model = Organization
fields = ('pk', 'ext_id', 'short_name', 'name', 'internal_id', 'ico',
'parent', 'is_admin', 'is_member') + tuple(
'name_' + lang[0] for lang in settings.LANGUAGES)
class FormattedCoursePriceSerializer(serializers.Serializer):
"""
Serializer for the format returned by
`financialaid.api.get_formatted_course_price`.
Primarily exists to convert `price` from decimal to string.
"""
program_id = IntegerField()
price = DecimalField(max_digits=None, decimal_places=2)
financial_aid_availability = BooleanField()
has_financial_aid_request = BooleanField()
class UserSerializer(HalNestedFieldsModelSerializer):
isSuperAdmin = BooleanField(source="is_superuser", read_only=True)
isSuperReader = BooleanField(source="is_staff", read_only=True)
email = EmailField(required=True)
class Meta:
model = get_user_model()
fields = ('id', 'email', 'password', 'first_name', 'last_name',
'isSuperAdmin', 'isSuperReader')
extra_kwargs = {'password': {'write_only': True}}
read_only_fields = ('id', )
class DocumentStateSerializer(EmbeddedDocumentSerializer):
is_archived = BooleanField(default=False)
archived_at = BDateField()
is_closed = BooleanField(default=False)
closed_at = BDateField()
is_draft = BooleanField(default=True)
is_valid = BooleanField(default=False)
class Meta:
model = DocumentState
fields = ['is_archived', 'archived_at', 'is_closed', 'closed_at', 'is_draft', 'is_valid']
class TableColumnsSerializer(EmbeddedDocumentSerializer):
label = CharField()
name = CharField()
type = CharField()
description = CharField(default='', allow_null=True)
unit = CharField(allow_null=True, allow_blank=True)
order_by = CharField(required=False, allow_blank=True)
is_orderable = BooleanField(default=False)
is_searchable = BooleanField(default=False)
is_editable = BooleanField(default=False)
is_global_searchable = BooleanField(default=False)
is_required = BooleanField(default=False)
is_ref = BooleanField(default=False)
module = CharField(default=None, allow_null=True)
model = CharField(default=None, allow_null=True)
rounded = BooleanField(default=False, required=False)
show_in = BEmbeddedListField(serializer=AllowPropertyNamespaceSerializer, required=False, allow_null=True)
order_in = BEmbeddedListField(serializer=ValuePropertyNamespaceSerializer, required=False, allow_null=True)
icon_name = CharField(required=False, allow_blank=True, allow_null=True)
is_extended = BooleanField(default=False)
colspan = IntegerField(default=1)
style_classes = BEmbeddedListField(serializer=TableClassesSerializer, required=False, allow_null=True)
class Meta:
model = TableColumns
fields = "__all__"
class DimensionSerializer(OrganizationSourceExtractingMixin, ModelSerializer):
public = BooleanField(default=False)
class Meta:
model = Dimension
fields = ('pk', 'short_name', 'name', 'name_cs', 'name_en', 'type',
'source', 'public')
validators = [
] # this removes the implicit required validation on source
def validate(self, attrs):
result = super().validate(attrs)
# extra validation for short_name in combination with source=NULL
exclude = {'pk': attrs['pk']} if 'pk' in attrs else {}
short_name = attrs.get('short_name')
if attrs.get('public'):
if Dimension.objects.exclude(**exclude).\
filter(source__isnull=True, short_name=short_name).exists():
raise ValidationError(
_('Public dimension with this code name already exists'))
else:
source = self._get_organization_data_source()
if Dimension.objects.exclude(**exclude).\
filter(source=source, short_name=short_name).exists():
raise ValidationError(
_('Dimension with this code name already exists'))
return result
def create(self, validated_data):
# we need to make sure source is properly assigned for non-public dimensions
if not validated_data.get('source') and not validated_data['public']:
validated_data['source'] = self._get_organization_data_source()
validated_data.pop('public')
return super().create(validated_data)
def filter_queryset(self, request, queryset, view):
past = request.query_params.get('all', 'false')
past = BooleanField().to_internal_value(past)
if not past:
now = datetime.now()
return queryset.filter(end__gte=now)
return queryset
def filter_queryset(self, request, queryset, view):
params = request.query_params
times = {}
past = False
for name in ('start', 'end'):
if name not in params:
continue
# whenever date filtering is in use, include past reservations
past = True
try:
times[name] = arrow.get(params[name]).to('utc').datetime
except ParserError:
raise exceptions.ParseError(
"'%s' must be a timestamp in ISO 8601 format" % name)
if not past:
past = params.get('all', 'false')
past = BooleanField().to_internal_value(past)
if not past:
now = datetime.now()
queryset = queryset.filter(end__gte=now)
if times.get('start', None):
queryset = queryset.filter(end__gte=times['start'])
if times.get('end', None):
queryset = queryset.filter(begin__lte=times['end'])
return queryset
class OrganizationConventionSerializer(EmbeddedDocumentSerializer):
is_default = BooleanField(default=False)
convention = BReferenceField(serializer=ConventionSerializer)
class Meta:
model = OrganizationConvention
fields = ("is_default", "convention")
class ManualDataUploadSerializer(ModelSerializer):
user = HiddenField(default=CurrentUserDefault())
import_batch = ImportBatchSerializer(read_only=True)
can_edit = BooleanField(read_only=True)
class Meta:
model = ManualDataUpload
fields = ('pk', 'report_type', 'organization', 'platform', 'data_file',
'user', 'created', 'is_processed', 'log', 'import_batch',
'extra', 'can_edit', 'owner_level')
def validate(self, attrs):
attrs = super().validate(attrs)
return attrs
def update(self, instance: ManualDataUpload, validated_data):
result = super().update(instance, validated_data) # type: Annotation
return self._adjust_permissions(result)
def create(self, validated_data):
result = super().create(validated_data)
return self._adjust_permissions(result)
@classmethod
def _adjust_permissions(cls, instance: ManualDataUpload):
if instance.user:
instance.owner_level = \
instance.user.organization_relationship(instance.organization_id)
# we do not want to set the level too high in order for the staff to be able to edit it
if instance.owner_level > UL_CONS_STAFF:
instance.owner_level = UL_CONS_STAFF
instance.save()
return instance
class AddMessageSerializer(serializers.HyperlinkedModelSerializer):
chat_id = IntegerField()
message = CharField(allow_blank=False)
is_admin = BooleanField()
class Meta:
model = Message
fields = ('chat_id', 'message', 'is_admin')
def validate(self, data):
chat_id = data['chat_id']
chat_qs = Chat.objects.filter(id=chat_id)
if not chat_qs.exists():
raise serializers.ValidationError(
'This dialog has not already created')
else:
chat_obj = chat_qs.first()
is_admin = data['is_admin']
if is_admin and chat_obj.admin_id == None:
raise serializers.ValidationError('Incorrect field is_admin')
return data
def create(self, validated_data):
chat_id = validated_data['chat_id']
message = validated_data['message']
is_admin = validated_data['is_admin']
message_obj = Message(chat_id=chat_id,
message=message,
is_admin=is_admin,
is_read=False)
message_obj.save()
return validated_data
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 PickupMemberSerializer(serializers.ModelSerializer):
"""Pickup member serializer"""
confirmed = BooleanField()
class Meta:
model = UserModel
fields = ['id', 'first_name', 'confirmed', 'phone', 'mobile', 'photo']
class ListingQuerySerializer(Serializer):
"""GET Listings list query serializer."""
orderable_fields = ('title', 'price', 'quantity', 'views', 'date_created',
'location', 'category')
default_ordering = '-price'
order_by = CharField(default=default_ordering)
title = CharField(required=False)
min_price = IntegerField(min_value=0, required=False)
max_price = IntegerField(min_value=0, required=False)
condition_new = BooleanField(required=False, allow_null=True, default=None)
category = CharField(required=False)
seller = Base64UUIDField(required=False)
def validate_order_by(self, order_by):
if not order_by.removeprefix('-') in self.orderable_fields:
return self.default_ordering
return order_by
def to_representation(self, validated_data):
filters = {}
if title := validated_data.get('title'):
filters['title__icontains'] = title
if min_price := validated_data.get('min_price'):
filters['price__gte'] = min_price
class AuthenticatorSMSChallenge(WithUserInfoChallenge):
"""SMS Setup challenge"""
# Set to true if no previous prompt stage set the phone number
# this stage will also check prompt_data.phone
phone_number_required = BooleanField(default=True)
component = CharField(default="ak-stage-authenticator-sms")
class AllowPropertyNamespaceSerializer(EmbeddedDocumentSerializer):
name = CharField(required=True)
allow = BooleanField(default=True)
class Meta:
model = AllowPropertyNamespace
fields = "__all__"
class OutpostHealthSerializer(PassiveSerializer):
"""Outpost health status"""
last_seen = DateTimeField(read_only=True)
version = CharField(read_only=True)
version_should = CharField(read_only=True)
version_outdated = BooleanField(read_only=True)
class AcademicPlanShortSerializer(serializers.ModelSerializer):
#discipline_blocks_in_academic_plan = DisciplineBlockSerializer(many=True, requirлинed=False)
can_edit = BooleanField(read_only=True)
academic_plan_in_field_of_study = ImplementationAcademicPlanShortForAPSerializer(
many=True)
def to_representation(self, instance):
data = super().to_representation(instance)
data["can_edit"] = self.context[
'request'].user.id == instance.author or bool(
self.context['request'].user.groups.filter(
name="academic_plan_developer"))
return data
class Meta:
model = AcademicPlan
fields = [
'id', 'educational_profile', 'number', 'approval_date', 'year',
'education_form', 'qualification', 'author', "can_edit",
'academic_plan_in_field_of_study'
]
extra_kwargs = {
'discipline_blocks_in_academic_plan': {
'required': False
}
}
class EventCreateAndUpdateSerializer(TagSerializerMixin, BasisModelSerializer):
cover = ImageField(required=False, options={'height': 500})
responsible_group = AbakusGroupField(queryset=AbakusGroup.objects.all(),
required=False,
allow_null=True)
pools = PoolCreateAndUpdateSerializer(many=True, required=False)
text = ContentSerializerField()
is_abakom_only = BooleanField(required=False, default=False)
registration_close_time = serializers.DateTimeField(read_only=True)
class Meta:
model = Event
fields = ('id', 'title', 'cover', 'description', 'text', 'company',
'responsible_group', 'feedback_description',
'feedback_required', 'event_type', 'location', 'is_priced',
'price_member', 'price_guest', 'use_stripe',
'payment_due_date', 'start_time', 'end_time', 'merge_time',
'use_captcha', 'tags', 'pools', 'unregistration_deadline',
'pinned', 'heed_penalties', 'is_abakom_only',
'registration_deadline_hours', 'registration_close_time')
def create(self, validated_data):
pools = validated_data.pop('pools', [])
is_abakom_only = validated_data.pop('is_abakom_only', False)
with transaction.atomic():
event = super().create(validated_data)
for pool in pools:
permission_groups = pool.pop('permission_groups')
created_pool = Pool.objects.create(event=event, **pool)
created_pool.permission_groups.set(permission_groups)
event.set_abakom_only(is_abakom_only)
return event
def update(self, instance, validated_data):
pools = validated_data.pop('pools', None)
is_abakom_only = validated_data.pop('is_abakom_only', False)
with transaction.atomic():
if pools is not None:
existing_pools = list(instance.pools.all().values_list(
'id', flat=True))
for pool in pools:
pool_id = pool.get('id', None)
if pool_id in existing_pools:
existing_pools.remove(pool_id)
permission_groups = pool.pop('permission_groups')
created_pool = Pool.objects.update_or_create(
event=instance,
id=pool_id,
defaults={
'name': pool.get('name'),
'capacity': pool.get('capacity', 0),
'activation_date': pool.get('activation_date'),
})[0]
created_pool.permission_groups.set(permission_groups)
for pool_id in existing_pools:
Pool.objects.get(id=pool_id).delete()
instance.set_abakom_only(is_abakom_only)
return super().update(instance, validated_data)
class AnnotationSerializer(ModelSerializer):
organization = OrganizationSerializer(read_only=True)
platform = PlatformSerializer(read_only=True)
subject = ReadOnlyField()
organization_id = PrimaryKeyRelatedField(
source='organization',
write_only=True,
allow_null=True,
queryset=Organization.objects.all())
platform_id = PrimaryKeyRelatedField(source='platform',
write_only=True,
allow_null=True,
queryset=Platform.objects.all())
can_edit = BooleanField(read_only=True)
submitter = HiddenField(default=CurrentUserDefault())
class Meta:
model = Annotation
fields = ('pk', 'organization_id', 'platform_id', 'subject',
'subject_en', 'subject_cs', 'short_message',
'short_message_en', 'short_message_cs', 'message',
'message_en', 'message_cs', 'start_date', 'end_date',
'organization', 'platform', 'level', 'can_edit', 'submitter')
extra_kwargs = {
'subject_en': {
'allow_blank': False
},
'subject_cs': {
'allow_blank': False
},
}
def update(self, instance: Annotation, validated_data):
# in patch updates, the submitter field might not be present
submitter = validated_data.pop('submitter',
None) or self.context['request'].user
if not instance.can_edit(submitter):
raise PermissionDenied(
'User is not allowed to edit this object - it is locked.')
result = super().update(instance, validated_data) # type: Annotation
return self._adjust_permissions(result, submitter)
def create(self, validated_data):
submitter = validated_data.pop('submitter') # type: User
result = super().create(validated_data)
return self._adjust_permissions(result, submitter)
@classmethod
def _adjust_permissions(cls, instance: Annotation, submitter: User):
instance.author = submitter
instance.owner_level = submitter.organization_relationship(instance.organization_id) \
if instance.organization_id else UL_CONS_STAFF
# we do not want to set the level too high in order for the staff to be able to edit it
if instance.owner_level > UL_CONS_STAFF:
instance.owner_level = UL_CONS_STAFF
instance.save()
instance.can_edit = instance.can_edit(submitter)
return instance
class SharedGroupSerializer(EmbeddedDocumentSerializer):
user = BDynamicField()
access = ListField(child=CharField())
is_owner = BooleanField(default=False)
class Meta:
model = SharedGroup
fields = '__all__'
class IdentificationChallenge(Challenge):
"""Identification challenges with all UI elements"""
user_fields = ListField(child=CharField(),
allow_empty=True,
allow_null=True)
password_fields = BooleanField()
application_pre = CharField(required=False)
enroll_url = CharField(required=False)
recovery_url = CharField(required=False)
passwordless_url = CharField(required=False)
primary_action = CharField()
sources = LoginSourceSerializer(many=True, required=False)
show_source_labels = BooleanField()
component = CharField(default="ak-stage-identification")
class UserActionResSerializer(Serializer):
result = BooleanField(required=True)
error_message = CharField(required=False, default=None)
auth_token = CharField(required=False)
### TODO: ModelSerializer를 상속받으면, 해당 기능을 정확히 어떻게 상속하는지? (예: 필드 등)
