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를 상속받으면, 해당 기능을 정확히 어떻게 상속하는지? (예: 필드 등)