class MembershipSerializer(SetModifyingUserOnIdentityMixin,
serializers.ModelSerializer):
identity = serializers.ResourceRelatedField(
queryset=models.Identity.objects.filter(is_organisation=False))
organisation = serializers.ResourceRelatedField(
queryset=models.Identity.objects.filter(is_organisation=True))
time_slot = DateRangeField()
included_serializers = {
"role": MembershipRoleSerializer,
}
def validate(self, *args, **kwargs):
validated_data = super().validate(*args, **kwargs)
if not self.instance:
return validated_data
for field in ["identity", "organisation"]:
if validated_data.get(field) and validated_data[field] != getattr(
self.instance, field):
raise ValidationError(f'Field "{field}" can\'t be modified.')
return validated_data
class Meta:
model = models.Membership
fields = (
"identity",
"organisation",
"role",
"authorized",
"time_slot",
"next_election",
"comment",
"inactive",
)
class EthActionSerializer(serializers.ModelSerializer):
transaction = serializers.ResourceRelatedField(
queryset=Transaction.objects.all())
transaction_receipt = serializers.ResourceRelatedField(
source='transactionreceipt', queryset=TransactionReceipt.objects.all())
explorer_hash = serializers.SerializerMethodField()
class Meta:
model = EthAction
fields = '__all__'
included_serializers = {
'transaction': TransactionSerializer,
'transaction_receipt': TransactionReceiptSerializer,
'async_job': AsyncJobSerializer,
'shipment': FKShipmentSerializer
}
class JSONAPIMeta:
included_resources = [
'transaction', 'transaction_receipt', 'async_job'
]
def get_explorer_hash(self, obj):
if hasattr(obj, 'transactionreceipt'):
return obj.transactionreceipt.evm_hash or obj.transaction_hash
return None
class ProjectSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = models.Project
fields = ('url', 'title', 'description', 'slug', 'owner', 'entities',
'components')
read_only_fields = (
'created',
'modified',
)
lookup_field = 'slug'
extra_kwargs = {'url': {'lookup_field': 'slug'}}
slug = serializers.SlugField(read_only=True)
owner = serializers.ResourceRelatedField(
read_only=True,
related_link_view_name='user-detail',
related_link_url_kwarg='pk')
entities = serializers.ResourceRelatedField(
read_only=True,
many=True,
related_link_view_name='entity-list',
related_link_url_kwarg='project_slug')
components = serializers.ResourceRelatedField(
read_only=True,
many=True,
related_link_view_name='component-list',
related_link_url_kwarg='project_slug')
included_serializers = {
'entities': EntitySerializer,
'components': ComponentSerializer,
'flows': FlowSerializer
}
class MatchSerializer(serializers.ModelSerializer):
"""Serializer for game model."""
winner = serializers.ResourceRelatedField(read_only=True, model=User)
match_completed = serializers.BooleanField(read_only=True)
class Meta:
"""Serializer meta information."""
model = models.Match
fields = ["player_1", "player_2", "winner", "match_completed", "games"]
extra_kwargs = {"games": {"read_only": True}}
included_serializers = {"games": "table_tennis.serializers.GameSerializer"}
def validate(self, attrs):
player_1 = attrs.get("player_1", getattr(self.instance, "player_1", None))
player_2 = attrs.get("player_2", getattr(self.instance, "player_2", None))
match_completed = attrs.get(
"match_completed", getattr(self.instance, "match_completed", None)
)
winner = attrs.get("winner", getattr(self.instance, "winner", None))
if player_1 == player_2:
raise serializers.ValidationError(
{"player_1": "two different players required"}
)
return attrs
class TicketSerializer(serializers.ModelSerializer):
id = serializers.CharField()
activation_link = serializers.SerializerMethodField()
scanned = serializers.BooleanField(read_only=True)
included_serializers = {
'offline_lecture': OfflineLectureSerializer,
}
customer_email = serializers.EmailField(source='customer.email')
offline_lecture_id = serializers.CharField(source='offline_lecture.id')
offline_lecture = serializers.ResourceRelatedField(read_only=True)
class Meta:
model = Ticket
fields = [
'id',
'customer_email',
'activation_link',
'offline_lecture',
'scanned',
'offline_lecture_id',
]
def get_activation_link(self, obj):
if obj.get_qr_code():
return f"{settings.SITE_URL}/api/tickets/activate/{obj.qrcode.code}"
return ""
def create(self, validated_data):
customer = validated_data.get('customer')
offline_lecture = validated_data.get('offline_lecture')
customer = User.objects.get(email=customer.get('email'))
offline_lecture = OfflineLecture.objects.get(
id=offline_lecture.get('id'))
return Ticket.objects.create(customer=customer,
offline_lecture=offline_lecture)
class TokenSerializer(
serializers.IncludedResourcesValidationMixin,
serializers.SparseFieldsetsMixin,
auth_serializers.TokenSerializer,
):
"""Set the pk of the instance to be the user's pk."""
token = serializers.CharField(read_only=True, source="_backup_key")
user = serializers.ResourceRelatedField(read_only=True)
class Meta(auth_serializers.TokenSerializer.Meta):
"""Serializer meta information."""
fields = ["token", "user"]
class JSONAPIMeta:
"""JSONAPI meta information."""
resource_name = "sessions"
def __init__(self, *args, **kwargs):
"""Set the pk of the instance to be the user's pk."""
super().__init__(*args, **kwargs)
if getattr(self, "instance", None):
self.instance._backup_key = self.instance.pk
self.instance.pk = self.context["request"].user.pk
class GameSerializer(serializers.ModelSerializer):
"""Serializer for game model."""
winner = serializers.ResourceRelatedField(read_only=True, model=User)
class Meta:
"""Serializer meta information."""
model = models.Game
fields = ["score_1", "score_2", "winner", "match"]
extra_kwargs = {"score_1": {"min_value": 0}, "score_2": {"min_value": 0}}
def validate(self, attrs):
match = attrs.get("match", getattr(self.instance, "match", None))
score_1 = attrs.get("score_1", getattr(self.instance, "score_1", None))
score_2 = attrs.get("score_2", getattr(self.instance, "score_2", None))
match_completed = match.match_completed
valid_score_diff = 2
both_less_than_11 = score_1 < 11 and score_2 < 11
lg_than_11_diff_lg_2 = (
not both_less_than_11 and abs(score_1 - score_2) < valid_score_diff
)
one_lg_11_one_less_11 = abs(score_1 - score_2) > valid_score_diff and (
score_1 > 11 or score_2 > 11
)
if lg_than_11_diff_lg_2 or both_less_than_11 or one_lg_11_one_less_11:
raise serializers.ValidationError({"score_1": "valid score required"})
if match_completed:
raise serializers.ValidationError({"match_completed": "match is completed"})
return attrs
class LibrarySerializer(serializers.ModelSerializer):
creator = ProfileSerializer(read_only=True)
files = serializers.ResourceRelatedField(many=True, read_only=True)
included_serializers = {
'files': 'scholar.apps.papers.serializers.FileSerializer'
}
class Meta:
model = Library
fields = (
'id',
'name',
'description',
'color',
'creator',
'files',
)
def create(self, validated_data):
creator = self.context.get('creator', None)
library = Library.objects.create(creator=creator, **validated_data)
return library
class JSONAPIMeta:
included_resources = ['files']
class MeSerializer(BaseSerializer):
acls = serializers.ResourceRelatedField(many=True, read_only=True)
included_serializers = {
"acls": "emeis.core.serializers.ACLSerializer",
}
class Meta:
model = User
fields = "__all__"
class FileSerializer(BaseSerializer):
renderings = serializers.ResourceRelatedField(
required=False,
many=True,
read_only=True,
)
included_serializers = {
"document": "alexandria.core.serializers.DocumentSerializer",
"original": "alexandria.core.serializers.FileSerializer",
"renderings": "alexandria.core.serializers.FileSerializer",
}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# We only want to provide an upload_url on creation of a file.
self.new = False
if "request" in self.context and self.context[
"request"].method == "POST":
self.new = True
download_url = serializers.CharField(read_only=True)
upload_url = serializers.SerializerMethodField()
def get_upload_url(self, obj):
return obj.upload_url if self.new else ""
def validate(self, *args, **kwargs):
validated_data = super().validate(*args, **kwargs)
if validated_data.get(
"type") != models.File.ORIGINAL and not validated_data.get(
"original"):
f_type = validated_data.get("type")
raise ValidationError(
f'"original" must be set for type "{f_type}".')
if validated_data.get(
"type") == models.File.ORIGINAL and validated_data.get(
"original"):
f_type = validated_data.get("type")
raise ValidationError(
f'"original" must not be set for type "{f_type}".')
return validated_data
class Meta:
model = models.File
fields = BaseSerializer.Meta.fields + (
"type",
"name",
"original",
"renderings",
"document",
"download_url",
"upload_url",
)
class ScopeSerializer(BaseSerializer):
acls = serializers.ResourceRelatedField(many=True, read_only=True)
included_serializers = {
"acls": "emeis.core.serializers.ACLSerializer",
}
class Meta:
model = Scope
exclude = ("level", "lft", "rght", "tree_id")
class WriteonlyTestSerializer(serializers.ModelSerializer):
'''Serializer for testing the absence of write_only fields'''
comments = serializers.ResourceRelatedField(
many=True, write_only=True, queryset=Comment.objects.all())
rating = serializers.IntegerField(write_only=True)
class Meta:
model = Entry
fields = ('comments', 'rating')
class AsyncJobSerializer(EnumSupportSerializerMixin,
serializers.ModelSerializer):
message_set = serializers.ResourceRelatedField(queryset=Message.objects,
many=True)
actions = serializers.ResourceRelatedField(queryset=AsyncAction.objects,
many=True)
state = UpperEnumField(JobState, lenient=True, ints_as_names=True)
class Meta:
model = AsyncJob
exclude = ('wallet_lock_token', )
include = {
"actions": ActionSerializer(),
}
included_serializers = {
'message_set': MessageSerializer,
'actions': ActionSerializer,
}
class JSONAPIMeta:
included_resources = ['message_set', 'actions']
class SessionSerializer(
serializers.IncludedResourcesValidationMixin,
serializers.SparseFieldsetsMixin,
serializers.Serializer,
):
"""Session serializer."""
user = serializers.ResourceRelatedField(model=User, read_only=True)
class JSONAPIMeta:
"""JSONAPI meta information."""
resource_name = "sessions"
class RoleSerializer(BaseSerializer):
permissions = serializers.ResourceRelatedField(
queryset=Permission.objects.all(), required=False, many=True)
included_serializers = {
"permissions": PermissionSerializer,
}
class Meta:
model = Role
fields = BaseSerializer.Meta.fields + (
"slug",
"name",
"description",
"permissions",
)
class VideoCourseSerializer(serializers.ModelSerializer):
is_released = serializers.SerializerMethodField()
course_parts = serializers.ResourceRelatedField(source='parts',
many=True,
read_only=True)
lectures = serializers.ResourceRelatedField(many=True, read_only=True)
included_serializers = {
'lecturer': events_serializers.LecturerSerializer,
'category': events_serializers.CategorySerializer,
'course_type': VideoCourseTypeSerializer,
'lectures': CourseLectureSerializer,
'allowed_memberships': MembershipField,
'course_parts': VideoCoursePartSerializer,
}
class Meta:
model = VideoCourse
fields = [
'allowed_memberships',
'category',
'course_type',
'course_parts',
'description',
'id',
'is_released',
'lecturer',
'lectures',
'name',
'parts',
'price',
'price_currency',
'release_date',
]
def get_is_released(self, obj):
return obj.is_released
class EntitySerializer(serializers.HyperlinkedModelSerializer):
class Meta:
model = models.Entity
fields = ('url', 'name', 'slug', 'description', 'components')
url = relations.NestedHyperlinkedIdentityField(
view_name='entity-detail',
parent_lookup_kwargs={'project_slug': 'project__slug'})
slug = serializers.SlugField(
default=serializers.CreateOnlyDefault(SlugDefault('name')))
components = serializers.ResourceRelatedField(
read_only=True,
many=True,
related_link_view_name='component-list',
related_link_url_kwarg='project_slug')
class DocumentSerializer(BaseSerializer):
files = serializers.ResourceRelatedField(
queryset=models.File.objects.all(), required=False, many=True)
included_serializers = {
"category": CategorySerializer,
"tags": TagSerializer,
"files": FileSerializer,
}
class Meta:
model = models.Document
fields = BaseSerializer.Meta.fields + (
"files",
"title",
"description",
"category",
"tags",
)
class EntrySerializer(serializers.Serializer):
blog = serializers.IntegerField()
comments = CommentSerializer(many=True, required=False)
comment = CommentSerializer(required=False)
headline = serializers.CharField(allow_null=True, required=True)
body_text = serializers.CharField()
author = serializers.ResourceRelatedField(queryset=Author.objects.all(),
required=False)
def validate(self, attrs):
body_text = attrs["body_text"]
if len(body_text) < 5:
raise serializers.ValidationError({
"body_text": {
"title": "Too Short title",
"detail": "Too short"
}
})
class BaseSerializer(serializers.ModelSerializer):
created_at = serializers.DateTimeField(read_only=True)
modified_at = serializers.DateTimeField(read_only=True)
created_by_user = serializers.ResourceRelatedField(read_only=True)
def create(self, validated_data):
user = self.context["request"].user
if not isinstance(user, AnonymousUser):
validated_data["created_by_user"] = user
return super().create(validated_data)
def validate(self, *args, **kwargs):
validated_data = super().validate(*args, **kwargs)
self.Meta.model.check_permissions(self.context["request"])
if self.instance is not None:
self.instance.check_object_permissions(self.context["request"])
return validated_data
class Meta:
fields = ("created_at", "modified_at", "created_by_user", "meta")
class CommentSerializer(serializers.ModelSerializer):
post = serializers.ResourceRelatedField(queryset=models.Post.objects.all())
class Meta:
model = models.Comment
class BaseSerializer(serializers.ModelSerializer):
created_at = serializers.DateTimeField(read_only=True)
modified_at = serializers.DateTimeField(read_only=True)
created_by_user = serializers.ResourceRelatedField(read_only=True)
class PlainRelatedResourceTypeSerializer(serializers.Serializer):
basic_models = serializers.ResourceRelatedField(
many=True, **related_field_kwargs
)
class PostSerializer(serializers.ModelSerializer):
comments = serializers.ResourceRelatedField(
queryset=models.Comment.objects.all(), many=True)
class Meta:
model = models.Post
