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()
