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