class FinishSerializer(ModelSerializer): url = SerializerMethodField() display_name = CharField() def get_url(self, obj): return f'/static/material/swatches/swatch_{obj.id}.jpg' class Meta: model = Finish fields = ['id', 'url', 'display_name']
class UserOptionSerializer(UserSerializer): value = IntegerField(source='id') text = CharField(source='full_name') class Meta(UserSerializer.Meta): fields = ( 'username', 'value', 'text', )
class StaffMinimalSerializer(DocumentSerializer): full_name = CharField(read_only=True) contact_info = ContactInfoSerializer(many=False, read_only=False, allow_null=True, required=False) class Meta: model = Staff fields = ('id', 'full_name', 'contact_info')
def test_validate_elements_valid(self): """ When a DictField is given a dict whose values are valid for the value-field, then validate will not raise a ValidationError. """ field = DictField(CharField(max_length=5)) try: field.validate({"a": "a", "b": "b", "c": "c"}) except ValidationError: self.fail("ValidationError was raised")
class MovieSerializer(serializers.HyperlinkedModelSerializer): uri = HyperlinkedIdentityField(view_name='Aplicacio:movie-detail') # cridar a les altres user = CharField(read_only=True) class Meta: model = Movie fields = ('uri', 'user', 'id', 'name', 'deck', 'duration', 'revenue', 'detail_url')
class LocalizedNameSerializer(ModelSerializer): uuid = CharField(read_only=True, source='id') name_type = CharField(source='type') type = CharField(source='name_type', required=False, allow_null=True, allow_blank=True) class Meta: model = LocalizedText fields = ( 'uuid', 'name', 'external_id', 'type', 'locale', 'locale_preferred', 'name_type', )
def test_validate_elements_valid(self): """ When a ListField is given a list whose elements are valid for the item-field, then validate will not raise a ValidationError. """ field = ListField(CharField(max_length=5)) try: field.validate(["a", "b", "c"]) except ValidationError: self.fail("ValidationError was raised")
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 AchievementSerializer(HyperlinkedModelSerializer): uri = HyperlinkedIdentityField(view_name='steamapp:achievement-detail') appid = HyperlinkedRelatedField(view_name='steamapp:game-detail', read_only=True) user = CharField(read_only=True) class Meta: model = Achievement fields = ('uri', 'apiname', 'appid', 'gamename', 'displayname', 'description', 'user')
class GamescoreSerializer(HyperlinkedModelSerializer): uri = HyperlinkedIdentityField(view_name='mygames:game-detail') game = HyperlinkedRelatedField(read_only=True, view_name='mygames:game-detail') user = CharField(read_only=True) class Meta: model = GameScore fields = ('uri', 'rating', 'user', 'date', 'game')
class GuerraSerializer(serializers.HyperlinkedModelSerializer): clan1 = HyperlinkedIdentityField(read_only=True, view_name='ClashofClans:clan_detail') clan2 = HyperlinkedRelatedField(read_only=True, view_name='ClashofClans:clan_detail') user = CharField(read_only=True) class Meta: model = Guerra fields = ('id', 'clan1', 'clan2', 'user')
class DishSerializer(HyperlinkedModelSerializer): uri = HyperlinkedIdentityField(view_name='myrestaurants:dish-detail') restaurant = HyperlinkedRelatedField( view_name='myrestaurants:restaurant-detail', read_only=True) user = CharField(read_only=True) class Meta: model = Dish fields = ('uri', 'name', 'description', 'price', 'image', 'user', 'date', 'restaurant')
class ArticlesSerializer(serializers.ModelSerializer): title = CharField(validators=[required]) excerpt = CharField(validators=[required]) text = CharField(validators=[required]) date_created = DateField(validators=[required]) date_updated = DateField(validators=[required]) writer = WritersSerializer(validators=[required]) def create(self, validated_data): writer_data = validated_data.pop('writer') article = Articles.objects.create(**validated_data, writer=Writers.objects.create( **writer_data)) return article class Meta: model = Articles fields = ('id', 'title', 'excerpt', 'text', 'date_created', 'date_updated', 'writer')
class AlumneSerializer(HyperlinkedModelSerializer): url = HyperlinkedIdentityField(view_name='alumne-detail') Curs = HyperlinkedRelatedField(many=True, read_only=True, view_name='curs-detail') user = CharField(read_only=True) class Meta: model = Alumne fields = ('url', 'name', 'nif', 'country', 'city', 'curs', 'user')
class AlbumReviewSerializer(HyperlinkedModelSerializer): uri = HyperlinkedIdentityField(view_name='waifufmapp:albumreview-detail') album = HyperlinkedRelatedField(view_name='waifufmapp:album-detail', read_only=True) user = CharField(read_only=True) class Meta: model = AlbumReview fields = ('uri', 'rating', 'comment', 'user', 'date', 'userlocation', 'album')
class CursSerializer(HyperlinkedModelSerializer): url = HyperlinkedIdentityField(view_name='curs-detail') titulacio = HyperlinkedRelatedField(many=True, read_only=True, view_name='titulacio-detail') user = CharField(read_only=True) class Meta: model = Curs fields = ('url', 'year', 'titulacio', 'user')
class AulaSerializer(HyperlinkedModelSerializer): url = HyperlinkedIdentityField(view_name='aula-detail') curs = HyperlinkedRelatedField(many=True, read_only=True, view_name='curs-detail') user = CharField(read_only=True) class Meta: model = Aula fields = ('url', 'name', 'capacity', 'curs', 'user')
class RestaurantReviewSerializer(HyperlinkedModelSerializer): uri = HyperlinkedIdentityField( view_name='myrestaurants:restaurantreview-detail') restaurant = HyperlinkedRelatedField( view_name='myrestaurants:restaurant-detail', read_only=True) user = CharField(read_only=True) class Meta: model = RestaurantReview fields = ('uri', 'rating', 'comment', 'user', 'date', 'restaurant')
class AuthorSerializer(ModelSerializer): gravatar_hash = SerializerMethodField() name = CharField() class Meta: model = UserProfile fields = ('gravatar_hash', 'name') def get_gravatar_hash(self, obj): return hashlib.md5(obj.email.lower()).hexdigest()
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 EventReadDetailedSerializer(TagSerializerMixin, BasisModelSerializer): comments = CommentSerializer(read_only=True, many=True) comment_target = CharField(read_only=True) cover = ImageField(required=False, options={"height": 500}) company = CompanyField(queryset=Company.objects.all()) responsible_group = AbakusGroupField(queryset=AbakusGroup.objects.all(), required=False, allow_null=True) pools = PoolReadSerializer(many=True) active_capacity = serializers.ReadOnlyField() text = ContentSerializerField() created_by = PublicUserSerializer() registration_close_time = serializers.DateTimeField(read_only=True) class Meta: model = Event fields = ( "id", "title", "description", "cover", "text", "event_type", "location", "comments", "comment_target", "start_time", "end_time", "merge_time", "pools", "registration_close_time", "registration_deadline_hours", "unregistration_deadline", "company", "responsible_group", "active_capacity", "feedback_description", "feedback_required", "is_priced", "price_member", "price_guest", "use_stripe", "payment_due_date", "use_captcha", "waiting_registration_count", "tags", "is_merged", "heed_penalties", "created_by", "is_abakom_only", "registration_count", "survey", ) 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) 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', 'is_processing', 'released', )
class CommentSerializer(FlexFieldsModelSerializer): app_label = CharField(max_length=100, allow_blank=True, write_only=True) model = CharField(max_length=100, allow_blank=True, write_only=True) content_type = PrimaryKeyRelatedField(required=False, allow_null=True, queryset=ContentType.objects.all()) commented_user = SerializerMethodField() class Meta: model = Comment fields = ALL_FIELDS expandable_fields = { "content_type": (ContentTypeSerializer, { "source": "content_type" }), } def validate(self, attrs): if not attrs.get("content_type"): attrs["content_type"] = ContentType.objects.get( app_label=attrs.get("app_label"), model=attrs.get("model")) # no more use attrs.pop("app_label", None) attrs.pop("model", None) return attrs def get_commented_user(self, instance): qs = UserModel.objects.filter(username=instance.commented_by) if qs.exists(): result = qs.values().get() else: result = { "id": 0, "username": instance.commented_by, "first_name": None, "last_name": None, "email": None, } return result
class InvoiceLineSerializer(EmbeddedDocumentSerializer): details = BEmbeddedListField(serializer=DetailLineSerializer, allow_null=True, required=False) description = CharField() is_comment = BooleanField(default=False) line_doc = BDynamicField(allow_null=True, required=False) class Meta: model = InvoiceLine fields = ['details', 'description', 'is_comment', 'line_doc']
class AttachmentSerializer(ModelSerializer): url = SerializerMethodField('get_absolute_url') display_name = CharField(source='display_name') is_image = BooleanField(source='is_image') def get_absolute_url(self, obj): return absolutify(obj.get_absolute_url()) class Meta: model = CommAttachment fields = ('id', 'created', 'url', 'display_name', 'is_image')
class SourceListSerializer(ModelSerializer): short_code = CharField(source='mnemonic') owner = CharField(source='parent_resource') owner_type = CharField(source='parent_resource_type') owner_url = CharField(source='parent_url') id = CharField(source='version') class Meta: model = Source fields = ( 'short_code', 'name', 'url', 'owner', 'owner_type', 'owner_url', 'version', 'created_at', 'id', )
class StagedFileSerializer(ModelSerializer): filename = CharField(source="client_filename") uuid = UUIDField(source="file_id", read_only=True) extra_attrs = SerializerMethodField(source="get_extra_attrs") class Meta: model = StagedFile fields = ( "client_id", "end_byte", "extra_attrs", "file", "filename", "start_byte", "timeout", "total_size", "user_pk_str", "uuid", ) extra_kwargs = { "client_id": { "write_only": True }, "end_byte": { "write_only": True }, "file": { "write_only": True }, "start_byte": { "write_only": True }, "timeout": { "write_only": True }, "user_pk_str": { "write_only": True }, "total_size": { "write_only": True }, } def get_extra_attrs(self, *_): return {} def validate(self, attrs): instance = StagedFile(**attrs) instance.clean() # This is set in the clean method attrs.update({"file_id": instance.file_id}) return attrs
class DetailedArticleSerializer(TagSerializerMixin, BasisModelSerializer): author = PublicUserSerializer(read_only=True, source='created_by') comments = CommentSerializer(read_only=True, many=True) cover = ImageField(required=False, options={'height': 500}) comment_target = CharField(read_only=True) content = ContentSerializerField(source='text') class Meta: model = Article fields = ('id', 'title', 'cover', 'author', 'description', 'comments', 'comment_target', 'tags', 'content', 'created_at', 'pinned')
class IdentificationChallengeResponse(ChallengeResponse): """Identification challenge""" uid_field = CharField() component = CharField(default="ak-stage-identification") pre_user: Optional[User] = None def validate_uid_field(self, value: str) -> str: """Validate that user exists""" pre_user = self.stage.get_user(value) if not pre_user: sleep(0.150) LOGGER.debug("invalid_login", identifier=value) identification_failed.send(sender=self, request=self.stage.request, uid_field=value) raise ValidationError("Failed to authenticate.") self.pre_user = pre_user return value
class SAMLProviderImportSerializer(PassiveSerializer): """Import saml provider from XML Metadata""" name = CharField(required=True) # Using SlugField because https://github.com/OpenAPITools/openapi-generator/issues/3278 authorization_flow = SlugRelatedField( queryset=Flow.objects.filter( designation=FlowDesignation.AUTHORIZATION), slug_field="slug", ) file = FileField()