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 BillableItemSerializer(Serializer): type = ChoiceField([ 'missed_reservation', 'tool_usage', 'area_access', 'consumable', 'staff_charge', 'training_session' ]) name = CharField(max_length=200, read_only=True) details = CharField(max_length=500, read_only=True) account = CharField(max_length=200, read_only=True) account_id = IntegerField(read_only=True) project = CharField(max_length=200, read_only=True) project_id = IntegerField(read_only=True) application = CharField(max_length=200, read_only=True) user = CharField(max_length=255, read_only=True) username = CharField(max_length=200, read_only=True) user_id = IntegerField(read_only=True) start = DateTimeField(read_only=True) end = DateTimeField(read_only=True) quantity = DecimalField(read_only=True, decimal_places=2, max_digits=8) def update(self, instance, validated_data): pass def create(self, validated_data): pass class Meta: fields = '__all__'
def test_to_internal_value(self): f = ImplicitExpandableListField(child=ChoiceField( choices=["foo", "foo__bar", "bar"])) self.assertEqual(f.run_validation(["foo"]), ["foo"]) self.assertEqual(set(f.run_validation(["foo__bar"])), {"foo__bar", "foo"})
class UserCreateSerializer(ModelSerializer): username = CharField(validators=[UniqueValidator(queryset=User.objects.all())]) # need to make email optional ... prob should think through signup form a little email = CharField( validators=[UniqueValidator(queryset=User.objects.all())], required=False ) password = CharField(write_only=True, min_length=8) signed_up_from = CharField( write_only=True, min_length=8, required=False, default="", trim_whitespace=True ) timezone_string = ChoiceField( choices=pytz.all_timezones, required=False, default="US/Eastern" ) class Meta: model = User fields = ["username", "email", "password", "signed_up_from", "timezone_string"] # TODO test - does this work with just username / no email, etc. def create(self, validated_data): username = validated_data.pop("username") password = validated_data.pop("password") is_betterself_user = False if validated_data["signed_up_from"] == "betterself": is_betterself_user = True validated_data["is_betterself_user"] = is_betterself_user user = User.objects.create(username=username, **validated_data) user.set_password(password) user.save() return user
class DailyProductivityLogCreateUpdateSerializer( BaseCreateUpdateSerializer, ModelValidatorsMixin ): # allow an regular isoformat of milliseconds also be passed date = DateField(input_formats=["iso-8601"]) source = ChoiceField(choices=BETTERSELF_LOG_INPUT_SOURCES, default=WEB_INPUT_SOURCE) mistakes = CharField(trim_whitespace=True, default="", allow_blank=True) class Meta: model = DailyProductivityLog fields = ( "source", "date", "very_productive_time_minutes", "productive_time_minutes", "neutral_time_minutes", "distracting_time_minutes", "very_distracting_time_minutes", "pomodoro_count", "notes", "mistakes", "user", ) def validate(self, validated_data): user = self.context["request"].user is_creating_instance = not self.instance if is_creating_instance: if self.Meta.model.objects.filter( user=user, date=validated_data["date"], ).exists(): raise ValidationError(f"Fields user and date need to be unique!") return validated_data
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 WellBeingLogCreateUpdateSerializer(BaseCreateUpdateSerializer, ModelValidatorsMixin): source = ChoiceField(INPUT_SOURCES_TUPLES, default=WEB_INPUT_SOURCE) class Meta: model = WellBeingLog fields = ( "mental_value", "physical_value", "time", "source", "notes", "user", ) def validate(self, validated_data): user = self.context["request"].user is_creating_instance = not self.instance if is_creating_instance: if self.Meta.model.objects.filter( user=user, time=validated_data["time"], ).exists(): raise ValidationError(f"Fields user and time are not unique!") return validated_data
class LoadAccountSerializer(serializers.Serializer): """ First tried to just declare a djmoney.contrib.MoneyField, but currency was still missing from the representation. (The currency we can see in the documentation only comes to life when there is a database MoneyField in a model). """ amount = DecimalField(max_digits=12, decimal_places=2) amount_currency = ChoiceField(choices=CURRENCY_CHOICES, default=DEFAULT_CURRENCY)
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 UsedBySerializer(PassiveSerializer): """A list of all objects referencing the queried object""" app = CharField() model_name = CharField() pk = CharField() name = CharField() action = ChoiceField(choices=[(x.name, x.name) for x in DeleteAction])
class ReportSerializer(ModelSerializer): object_type = ChoiceField( ["question", "answer", "comment", "profile", "tag", "course"]) comments = ModeratorCommentSerializer(many=True, required=False) class Meta: model = Report fields = ( "pk", "created_at", "updated_at", "closed_at", "text", "reporter", "status", "object_id", "object_type", "comments", ) read_only_fields = ( "pk", "created_at", "updated_at", "closed_at", "reporter", "status", "comments", ) def create(self, validated_data): report = Report( reporter=Profile.objects.get_or_create( user=self.context["request"].user)[0], text=validated_data["text"], object_id=validated_data["object_id"], ) if validated_data["object_type"] == "question": report.content_type = ContentType.objects.get(app_label="question", model="question") elif validated_data["object_type"] == "answer": report.content_type = ContentType.objects.get(app_label="question", model="answer") elif validated_data["object_type"] == "comment": report.content_type = ContentType.objects.get(app_label="question", model="comment") elif validated_data["object_type"] == "profile": report.content_type = ContentType.objects.get(app_label="account", model="profile") elif validated_data["object_type"] == "tag": report.content_type = ContentType.objects.get(app_label="question", model="questiontag") if report.content_object is None: raise ParseError() report.save() return report
class WarningSerializer(serializers.ModelSerializer): name = ChoiceField(choices=Warning.WARNINGS_CHOICES) class Meta: model = Warning fields = ( 'id', 'name', )
class StagePromptSerializer(PassiveSerializer): """Serializer for a single Prompt field""" field_key = CharField() label = CharField(allow_blank=True) type = ChoiceField(choices=FieldTypes.choices) required = BooleanField() placeholder = CharField(allow_blank=True) order = IntegerField() sub_text = CharField(allow_blank=True)
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 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 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 Challenge(PassiveSerializer): """Challenge that gets sent to the client based on which stage is currently active""" type = ChoiceField(choices=[(x.value, x.name) for x in ChallengeTypes], ) component = CharField(required=False) title = CharField(required=False) background = CharField(required=False) response_errors = DictField(child=ErrorDetailSerializer(many=True), allow_empty=True, required=False)
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 TaskSerializer(PassiveSerializer): """Serialize TaskInfo and TaskResult""" task_name = CharField() task_description = CharField() task_finish_timestamp = DateTimeField(source="finish_timestamp") status = ChoiceField( source="result.status.name", choices=[(x.name, x.name) for x in TaskResultStatus], ) messages = ListField(source="result.messages")
class Challenge(PassiveSerializer): """Challenge that gets sent to the client based on which stage is currently active""" type = ChoiceField( choices=[(x.value, x.name) for x in ChallengeTypes], ) flow_info = ContextualFlowInfo(required=False) component = CharField(default="") response_errors = DictField( child=ErrorDetailSerializer(many=True), allow_empty=True, required=False )
class SupplementLogCreateUpdateSerializer(BaseCreateUpdateSerializer): supplement_uuid = UUIDField(source="supplement.uuid") user = HiddenField(default=CurrentUserDefault()) uuid = UUIDField(required=False, read_only=True) notes = CharField( default="", trim_whitespace=True, required=False, allow_blank=True, ) quantity = DecimalField(decimal_places=4, max_digits=10, default=1) source = ChoiceField(INPUT_SOURCES_TUPLES, default=WEB_INPUT_SOURCE) class Meta: model = SupplementLog fields = ( "user", "uuid", "notes", "supplement_uuid", "source", "quantity", "time", "duration_minutes", ) def validate_supplement_uuid(self, value): user = self.context["request"].user validate_model_uuid(Supplement, uuid=value, user=user) return value def validate(self, validated_data): user = self.context["request"].user is_creating_instance = not self.instance if validated_data.get("supplement"): supplement_uuid = validated_data["supplement"]["uuid"] supplement = Supplement.objects.get(uuid=supplement_uuid, user=user) validated_data["supplement"] = supplement if is_creating_instance: if self.Meta.model.objects.filter( user=user, supplement=supplement, time=validated_data["time"], ).exists(): raise ValidationError( f"Fields user, supplement, and time are not unique!") return validated_data
class OAuthSourceSerializer(SourceSerializer): """OAuth Source Serializer""" provider_type = ChoiceField(choices=MANAGER.get_name_tuple()) callback_url = SerializerMethodField() def get_callback_url(self, instance: OAuthSource) -> str: """Get OAuth Callback URL""" relative_url = reverse_lazy( "authentik_sources_oauth:oauth-client-callback", kwargs={"source_slug": instance.slug}, ) if "request" not in self.context: return relative_url return self.context["request"].build_absolute_uri(relative_url) type = SerializerMethodField() @extend_schema_field(SourceTypeSerializer) def get_type(self, instance: OAuthSource) -> SourceTypeSerializer: """Get source's type configuration""" return SourceTypeSerializer(instance.type).data def validate(self, attrs: dict) -> dict: provider_type = MANAGER.find_type(attrs.get("provider_type", "")) for url in [ "authorization_url", "access_token_url", "profile_url", ]: if getattr(provider_type, url, None) is None: if url not in attrs: raise ValidationError(f"{url} is required for provider {provider_type.name}") return attrs class Meta: model = OAuthSource fields = SourceSerializer.Meta.fields + [ "provider_type", "request_token_url", "authorization_url", "access_token_url", "profile_url", "consumer_key", "consumer_secret", "callback_url", "additional_scopes", "type", ] extra_kwargs = {"consumer_secret": {"write_only": True}}
class EventSerializer(ModelSerializer): id = CharField(read_only=True) start = UnixEpochDateField() locations = PrimaryKeyRelatedField( many=True, pk_field=CharField(), queryset=LocationModel.objects.all().filter(deleted=False)) duration = DurationInSecondsField() category = ChoiceField(choices=EventModel.CATEGORIES) class Meta: model = EventModel fields = ('id', 'name', 'info', 'start', 'duration', 'locations', 'category', 'approved')
class ContactSerializer(serializers.Serializer): """Serializer for contact message.""" VOLUNTEER = 'volunteer' ORGANIZATION = 'organization' APPLICANT_CHOICES = (VOLUNTEER, ORGANIZATION) applicant_type = ChoiceField(APPLICANT_CHOICES, required=True) applicant_email = EmailField(required=True, max_length=150) applicant_name = CharField(required=True, min_length=3, max_length=150) administrator_email = EmailField( required=True, validators=[validate_admin_email], ) message = CharField(required=True, min_length=10, max_length=2000) phone_no = CharField(max_length=20)
class OrderListSerializer(ModelSerializer): pizzas_number = SerializerMethodField() customer = CustomerSerializer(read_only=True) status = ChoiceField(choices=Order.STATUS_CHOICES, read_only=True) pizzas = PizzaSerializer(many=True, read_only=True, source='pizzas.all') @staticmethod def get_pizzas_number(obj): return obj.pizzas.count() class Meta: model = Order ordering = ('-created', ) fields = ('id', 'pizzas', 'customer', 'status', 'details', 'pizzas_number')
class ArticleApprovalUpdateSerializer(ModelSerializer): written_by = WriterDetailSerializer(read_only=True) edited_by = WriterDetailSerializer(allow_null=True, read_only=True) action = ChoiceField(write_only=True, allow_blank=False, choices=APPROVAL_STATUS_CHOICES) class Meta: model = Article fields = ('id', 'title', 'content', 'status', 'created_at', 'written_by', 'edited_by', 'action') extra_kwargs = { 'id': { 'read_only': True }, 'title': { 'read_only': True }, 'content': { 'read_only': True }, 'status': { 'read_only': True }, 'created_at': { 'read_only': True }, } def update(self, instance, validated_data): # print('update') action = validated_data.get('action', None) if action is None: raise ValidationError('Action field missing!') if action == APPROVED: instance.status = APPROVED elif action == REJECTED: instance.status = REJECTED else: raise ValidationError( f"The field: 'action' must have one of the values:('{APPROVED},{REJECTED}')!" ) # print(self.validated_data) # print(self.context['writer']) instance.edited_by = self.context['writer'] instance.save() # return instance
class RegistrationTrashSerializer(serializers.ModelSerializer): consultant = UserBasicSerializer() costumer = PersonSerializer() status_removed = ChoiceField(choices=Registration.STATUS_CHOICES) class Meta: model = Registration fields = [ 'id', 'consultant', 'costumer', 'trash_date', 'deleted_date', 'status_removed', 'get_status_removed_display' ]
class SleepLogCreateUpdateSerializer(BaseCreateUpdateSerializer, ModelValidatorsMixin): source = ChoiceField(INPUT_SOURCES_TUPLES, default=WEB_INPUT_SOURCE) class Meta: model = SleepLog fields = ( "source", "start_time", "end_time", "notes", "user", ) def validate(self, validated_data): user = self.context["request"].user is_creating_instance = not self.instance end_time = validated_data.get("end_time") or self.instance.end_time start_time = validated_data.get( "start_time") or self.instance.start_time if start_time > end_time: raise ValidationError("End Time Must Occur After Start") if is_creating_instance: if self.Meta.model.objects.filter( user=user, start_time=validated_data["start_time"], end_time=validated_data["end_time"], ).exists(): raise ValidationError( f"Fields user, start_time, and end_time are not unique!") queryset = SleepLog.objects.filter(user=user, end_time__gte=start_time, start_time__lte=end_time) if queryset.exists(): duplicated = queryset.first() start_time_label = duplicated.start_time.date() raise ValidationError( f"Sleep Periods cannot overlap! Found overlapping on {start_time_label}" ) return validated_data
class MessageViewSerializer(serializers.ModelSerializer): sender = UserSerializer() chat = ChatViewSerializer() status = ChoiceField(choices=STATUS.choices) file_set = FileSerializer(many=True) class Meta: model = Message fields = ( "id", "sender", "chat", "text", "status", "created_at", "updated_at", "file_set", )
class InstanceSerializer(ModelSerializer): """Serialize a customer AwsInstance for API v2.""" cloud_type = ChoiceField(choices=CLOUD_PROVIDERS, required=False) content_object = GenericRelatedField( { AwsInstance: AwsInstanceSerializer(), AzureInstance: AzureInstanceSerializer(), }, required=False, ) instance_id = IntegerField(source="id", read_only=True) class Meta: model = Instance fields = ( "cloud_account_id", "created_at", "instance_id", "machine_image_id", "updated_at", "cloud_type", "content_object", ) read_only_fields = ( "cloud_account_id", "created_at", "id", "machine_image_id", "updated_at", ) def create(self, validated_data): """Create a Instance.""" raise NotImplementedError def update(self, instance, validated_data): """Update a Instance.""" raise NotImplementedError