class CommentDetailSerializer(serializers.ModelSerializer):
user = UserPublicSerializer(read_only=True)
reply_count = serializers.SerializerMethodField()
replies = serializers.SerializerMethodField()
class Meta:
model = Comment
fields = [
'id',
'user',
'content_type',
'object_id',
'content',
'replies',
'reply_count',
'timestamp',
]
def get_reply_count(self, obj):
if obj.is_parent:
return obj.children().count()
return 0
def get_replies(self, obj):
if obj.is_parent:
return CommentChildSerializer(obj.children(), many=True).data
return None
class BlogsSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
class Meta:
model = BlogsModel
fields = ['id', 'user', 'content', 'image', 'uri']
read_only_fields = ['user'] # GET
# def validate_content(self, value):
# if len(value) > 10000:
# raise serializers.ValidationError("Content Field too Large")
# return value
def validate(self, data):
content = data.get("content", None)
if content == "":
content = None
image = data.get("image", None)
if content is None and image is None:
raise serializers.ValidationError("Content or Image Required!")
return data
def get_uri(self, obj):
#return "/api/status/{id}/".format(id=obj.id)
request = self.context.get('request')
return api_reverse('api-blogs:details',
kwargs={"id": obj.id},
request=request)
class StatusSerializer(serializers.ModelSerializer):
user = UserPublicSerializer(read_only=True)
class Meta:
model = Status
fields = ['id', 'user', 'content', 'image']
read_only_fields = ['user']
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
#user = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
# user_id = serializers.PrimaryKeyRelatedField(source='user', read_only=True)
# user_id = serializers.HyperlinkedRelatedField(
# source='user', # user foreign key
# lookup_field='username',
# view_name='api-user:detail',
# read_only=True
# )
# user = serializers.SlugRelatedField(read_only=True, slug_field='username')
class Meta:
model = Status
fields = [
'uri',
# 'user_id',
'id', # ?? tmp for now,
'user',
'content',
'image'
]
read_only_fields = ['user']
# partial = True
def get_uri(self, obj):
request = self.context.get('request')
return api_reverse("api-status:detail",
kwargs={"id": obj.id},
request=request)
class StatusSerializer(serializers.ModelSerializer):
user = UserPublicSerializer(read_only=True)
uri = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Status
fields = [
'uri',
'id',
'user',
'content',
'image'
]
read_only_fields = ['user']
def validate_content(self,value):
if len(value)>240:
raise serializers.ValidationError('This is very long')
return value
def validate(self,data):
content = data.get('content',None)
if content =='':
content = None
image = data.get('image',None)
if content is None and image is None:
raise serializers.ValidationError('contetn or image required')
return data
def get_uri(self,obj):
return '/api/users/{id}/'.format(id=obj.id)
class PostSerializer(serializers.ModelSerializer):
user = UserPublicSerializer(read_only=True)
# Serializer Related Field
user_name = serializers.SlugRelatedField(source='user',
read_only=True,
slug_field="username")
class Meta:
model = Posts
fields = ["id", "user", "content", "post_image", "user_name"]
# The read_only_field attribute ensures that the field cannot be altered or written to (Typically used for default fields or user fields)
read_only_fields = ["user"]
# Validation
def validate_content(self, value):
if len(value) > 1000:
raise serializers.ValidationError(
"Content cannot be more than 1000 characters !")
return value
def validate(self, data):
content = data.get("content", None)
image = data.get("image", None)
if content == "":
content == None
if content == None and image == None:
raise serializers.ValidationError(
"Content or Image are Required !")
return data
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True) #nested serializer
class Meta:
model = Status
fields = [
'id',
'user',
'content',
'uri',
'image'
]
read_only_fields = ['user']
def get_uri(self,obj):
return "/api/user/{id}".format(id=obj.id)
def validate_content(self,value):
if len(value) < 10:
raise serializers.ValidationError("content are too short")
return value
def validate(self,data):
content = data.get('content',None)
if content == "":
content = None
image = data.get('image',None)
if content is None and image is None:
raise serializers.ValidationError("content or image is required")
return data
class StatusSerializer(serializers.ModelSerializer):
user = UserPublicSerializer(read_only=True)
uri = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Status
fields = ['uri', 'id', 'user', 'content', 'image']
read_only_fields = ['user']
def get_uri(self, obj):
return "/api/status/{id}".format(id=obj.id)
def validate_content(self, value):
if len(value) > 10000:
raise serializers.ValidatonError("This is way too long")
return value
def validate(self, data):
content = data.get("content", None)
if content == "":
content = None
image = data.get("image", None)
if content is None and image is None:
raise serializers.ValidatonError("Content or image is required")
return data
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
class Meta:
model = Status
fields = [
'uri',
'id',
'user',
'content',
'image',
]
#read_only_fields = ['user'] #GET calls it will be read only REGARDLESS of what is done in the view
def get_uri(self, obj):
#request = self.context.get('request')
return "/api/status/{id}/".format(
id=obj.id
) #api_reverse("api-user:detail", kwargs={"username": obj.username}, request=request)
def validate_content(self, value):
if len(value) > 1000:
raise serializers.ValidationError("This is way too long")
return value
def validate(self, data):
content = data.get("content", None)
if content == "":
content = None
image = data.get("image", None)
if content is None and image is None:
raise serializers.ValidationError("content or image is required.")
return data
class EventSerializer(serializers.ModelSerializer):
creator = UserPublicSerializer(read_only=True)
category = CategorySerializer()
tags = TagSerializer(many=True)
uri = serializers.SerializerMethodField()
class Meta:
model = Event
fields = (
'id',
'uri',
'title',
'creator',
'category',
'tags',
'description',
'event_date',
'location',
# 'latitude',
# 'longitude',
# 'attendees',
'created_on',
)
def get_uri(self, obj):
request = self.context.get('request')
return obj.get_api_uri(request=request)
class PersonSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
UserName = UserPublicSerializer(read_only=True)
class Meta:
model = Person
fields = [
'uri',
'UserName',
'PersonId',
'PersonName',
'Person_Image',
'Person_sex',
'Person_BDate',
'Person_CDate'
]
read_only_fields=['UserName'] # Get calls its gone be read only.
def get_uri(self,obj):
return "/api/Persons/{id}".format(id=obj.PersonId)
def validate_personName(self,value):
if len(value) > 30:
raise serializers.ValidationError("PersonName should not be more than 30 Char")
return value
def validate_personsex(self,value):
if value not in ['M','F','N']:
raise serializers.ValidationError("PersonSex should be M F or N")
return value
def validate_personbdate(self,value):
if datetime.datetime.strptime(value, '%Y-%m-%d'):
raise serializers.ValidationError("Incorrect data format, should be YYYY-MM-DD")
return value
def validate_personimg(self,value):
pass
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
# user_id = serializers.PrimaryKeyRelatedField(
# source='user', read_only=True)
# user_id = serializers.HyperlinkedRelatedField(
# source='user', lookup_field='username', view_name='api-user:detail', read_only=True)
# user = serializers.SlugRelatedField(read_only=True, slug_field='email'
# )
class Meta:
model = Status
fields = ['uri', 'user_id', 'id', 'user', 'content', 'image']
read_only_fields = ('user', )
def get_uri(self, obj):
request = self.context['request']
return api_reverse('api-status:detail',
kwargs={'id': obj.id},
request=request)
def validate(self, attrs):
content, image = attrs.get("content"), attrs.get('image')
if not content and not image:
raise serializers.ValidationError("Content or image is required")
return attrs
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
class Meta:
model = Status
fields = ['uri', 'id', 'user', 'content', 'image']
read_only_fields = ['user']
def get_uri(self, obj):
request = self.context.get('request')
return reverse('api-status:detail',
kwargs={'pk': obj.pk},
request=request)
# def validate_content(self, value):
# if len(value) > 240:
# raise serializers.ValidationError('This is way too long!')
# return value
def validate(self, data):
content = data.get('content', None)
if content == '':
content = None
image = data.get('image', None)
if content is None and image is None:
raise serializers.ValidationError('Content or image is required!')
return data
class TodosSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
# user = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
class Meta:
model = Todos
fields = [
'uri',
'id',
'user',
'title',
'completed'
]
read_only_fields = ['user']
# def get_user(self,obj):
# request = self.context.get('request')
# user = obj.user
# return UserPublicSerializer(user,read_only=True, context={"request":request}).data
def get_uri(self,obj):
request = self.context.get('request')
return api_reverse('api-todos:detail',kwargs={"id":obj.id}, request=request)
def validate_title(self, value):
if len(value) > 100:
raise serializers.ValidationError("This is way to short")
return value
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
class Meta:
model = Status
fields = [
'id',
'user',
'content',
'image',
'uri'
]
read_only_fields = ['user'] # GET #readyonly_fields
def get_uri(self, obj):
return f'api/status/{obj.id}'
# def validate_content(self, value):
# if len(value) > 10000:
# raise serializers.ValidationError('This is way too long.')
# return value
def validate(self, attrs):
content = attrs.get('content', None)
if content == '':
content = None
image = attrs.get('image', None)
if content is None and image is None:
raise serializers.ValidationError('Content or Image is required')
return attrs
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
# user = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
# # user_id = PrimaryKeyRelatedField(source='user', read_only=True)
# # user_uri = HyperlinkedRelatedField(
# # source='user', # user foreign key
# # lookup_field='username',
# # view_name='user-detail',
# # read_only=True)
# user = serializers.SlugRelatedField(read_only=True, slug_field='username')
class Meta:
# Do notice that these are almost the same as from `forms.py`.
# However, DRF serializers serializes the data into JSON as well as validate them for you!
model = Status
fields = [
'id',
'user',
'content',
'image',
'uri',
]
read_only_fields = ['user'] # GET # readonly_fields
def get_uri(self, obj):
request = self.context.get('request')
return api_reverse('status-detail',
kwargs={'pk': obj.id},
request=request)
def get_user(self, obj):
request = self.context.get('request')
user = obj.user
return UserPublicSerializer(user,
read_only=True,
context={
'request': request
}).data
# Single field validation example:
# def validate_<fieldname>(self, value):
# For example,
# def validate_content(self, value):
# if len(value) > 10000:
# raise serializers.ValidationError('This is way too long.')
# return value
def validate(self, data):
"""
Validates all fields of Status model.
"""
content = data.get('content', None)
if content == '':
content = None
image = data.get('image', None)
if content is None and image is None:
raise serializers.ValidationError('Content or image is required.')
return data
def get_user(self, obj):
request = self.context.get('request')
user = obj.user
return UserPublicSerializer(user,
read_only=True,
context={
'request': request
}).data
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
# user = serializers.SerializerMethodField(read_only=True)
# user_id = serializers.PrimaryKeyRelatedField(source='user', read_only=True)
user_url = serializers.HyperlinkedRelatedField(lookup_field='username',
view_name='api-user:detail',
source='user',
read_only=True)
# user_email = serializers.SlugRelatedField(read_only=True, source='user', slug_field='email')
class Meta:
model = Status
fields = [
'uri',
'id',
'user_url',
# 'user_email',
'user',
'content',
'image',
]
read_only_fields = ['user']
def get_uri(self, obj):
request = self.context['request']
return api_reverse('api-status:detail',
kwargs={'id': obj.id},
request=request)
# def get_user(self, obj):
# request = self.context['request']
# user = obj.user
# return UserPublicSerializer(user, read_only=True, context={'request': request}).data
"""
def validate_<fieldname>(self, value):
validation...
return value
"""
# Field level validation
# def validate_content(self, value):
# if len(value) > 10000:
# raise serializers.ValidationError("This is way too long.")
# return value
# Serializer level validation
def validate(self, data):
content = data.get('content', None)
if content == '':
content = None
image = data.get('image', None)
if image is None and content is None:
raise serializers.ValidationError('Content or image is required')
return data
class ReviewSerializer(serializers.ModelSerializer): user = UserPublicSerializer(read_only=True) class Meta: model = Review fields = ['id', 'user', 'title', 'book', 'content', 'timestamp']
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
# user = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
# user_id = serializers.PrimaryKeyRelatedField(source='user', read_only=True)
# user_id = serializers.HyperlinkedRelatedField(
# source='user', # user foreign key
# lookup_field='username',
# view_name='api-user:detail',
# read_only=True
# )
# username = serializers.SlugRelatedField(source='user', read_only=True, slug_field='username')
class Meta:
model = Status
fields = [
'id', #?
'user',
# 'user_id',
'content',
'image',
# 'username',
'uri',
]
read_only_fields = ['user'] # GET # readonly_fields
# def get_user(self, obj):
# request = self.context.get('request')
# user = obj.user
# return UserPublicSerializer(user, read_only=True, context={"request" : request}).data
def get_uri(self, obj):
request = self.context.get('request')
# return "/api/status/{id}/".format(id=obj.id)
return api_reverse('api-status:detail',
kwargs={'id': obj.id},
request=request)
# def validate_<fieldname>(self, value) i.e. validate_content
# def validate_content(self, value):
# if len(value) > 1000:
# raise serializers.ValidationError("this is way too long.")
# return value
def validate(self, data):
content = data.get("content", None)
if content == "":
content = None
image = data.get("image", None)
if content is None and image is None:
raise serializers.ValidationError("Content or image is required")
return data
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
class Meta:
model = StatusModel
fields = ["uri", "id", "user", "content", "image"]
read_only_fields = ['user']
def get_uri(self, obj):
return "/api/status/{id}/".format(id=obj.id)
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
user_id = serializers.PrimaryKeyRelatedField(source='user',
read_only=True)
user_link = serializers.HyperlinkedRelatedField(
source='user',
lookup_field='username',
view_name='api-user:detail',
read_only=True
)
username = serializers.SlugRelatedField(
source='user',
read_only=True,
slug_field='username'
)
# serializing model data
class Meta:
model = Status
fields = [
'uri',
'id',
'user',
'user_id',
'user_link',
'username',
'content',
'image'
]
read_only_fields = ['user'] # only allowed for GET calls
def get_uri(self, obj):
request = self.context.get('request')
# return "/api/status/{id}".format(id=obj.id)
return api_reverse('api-status:detail', kwargs={"id": obj.id},
request=request)
def validate_content(self, value):
# Fn to validate content of serializer - field level validation
if len(value) > 10000:
raise serializers.ValidationError("This is too long")
return value
def validate(self, data):
# Fn to validate all content types - model level validation
content = data.get("content", None) # default value None
if content == "": # if empty string - content set as None
content = None
image = data.get("image", None)
if content is None and image is None:
raise serializers.ValidationError("content or image is required.")
return data
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
# user = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
# user_id = serializers.PrimaryKeyRelatedField(source='user', read_only=True)
# user_id = serializers.HyperlinkedRelatedField(
# source='user',
# lookup_field='username',
# view_name='api-user:detail',
# read_only=True)
# username = serializers.SlugRelatedField(source='user', read_only=True, slug_field='email')
class Meta:
model = Status
fields = [
'uri',
# 'user_id',
'id',
'user',
'content',
'image'
]
read_only_fields = [
'user'
] # GET usado em conjunção com func perform_create em views
# def get_user(self, obj):
# request = self.context.get('request') # para meter os urls a funcionar
# user = obj.user
# return UserPublicSerializer(user, read_only=True, context={"request": request}).data
def get_uri(self, obj):
request = self.context.get('request')
return api_reverse('api-status:detail',
kwargs={'id': obj.id},
request=request)
# def validate_content(self, value):
# if len(value) > 10000:
# raise serializers.ValidationError("This is way to long.")
# return value
def validate(self, data):
content = data.get("content", None)
if content == "":
content = None
image = data.get("image", None)
if content is None and image is None:
raise serializers.ValidationError("Content or image is required")
return data
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
# user = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
# user_id =serializers.PrimaryKeyRelatedField(source='user', read_only=True)
# user_id = serializers.HyperlinkedRelatedField(
# source='user', # works for user foreign key
# lookup_field='username',
# view_name='api-user:detail',
# read_only=True
# )
# user =serializers.SlugRelatedField(read_only=True, slug_field='username') # source='email' <-- pulls email info
class Meta:
model = Status
fields = [
'uri',
# 'user_id',
'id', # ?
'user',
'content',
'image'
]
read_only_fields = ['user'] #GET calls only. change users anymore
# def get_user(self,obj):
# request = self.context.get('request')
# user = obj.user
# return UserPublicSerializer(user, read_only=True, context={"request"}).data
def get_uri(self, obj):
request = self.context.get('request')
return api_reverse('api-status:detail',
kwargs={'id': obj.id},
request=request)
#field level validation
# def validate_<fieldname>(self, value):
# def validate_content(self, value):
# if len(value) > 10000:
# raise serializers.ValidationError("This is way too long")
# return value
def validate(self, data):
content = data.get("content", None)
if content == "":
content = None
image = data.get("image", None)
if content is None and image is None:
raise serializers.ValidationError("content or image is required")
return data
class StatusSerializer(serializers.ModelSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
# user = serializers.PrimaryKeyRelatedField(read_only=True)#default
# user_id = serializers.PrimaryKeyRelatedField(source='user',read_only=True)#default
# user_id = serializers.HyperlinkedRelatedField(
# source='user', #user foreignkey
# lookup_field='username',
# view_name='user_detail',
# read_only=True)
# username = serializers.SlugRelatedField(source='user',read_only=True,slug_field='username')#'email')
# user = serializers.SlugRelatedField(read_only=True,slug_field='username')#'email')
class Meta:
model = Status
fields = (
# 'username',
# 'user_id',
'uri',
'id',
'user',
'content',
'image',
)
read_only_fields = ['user'] #GET
def get_uri(self, obj):
request = self.context.get('request')
return drf_reverse('status-detail',
kwargs={'pk': obj.pk},
request=request)
#serializer validation
def validate_content(self, value):
if len(value) > 400:
raise serializers.ValidationError("This way too long")
return value
def validate(self, data):
content = data.get('content', None)
if content == "":
content = None
image = data.get('image', None)
if content is None and image is None:
raise serializers.ValidationError('Content or image is required!')
return data
class StatusInlineUserSerializer(StatusSerializer):
uri = serializers.SerializerMethodField(read_only=True)
user = UserPublicSerializer(read_only=True)
# serializing model data
class Meta:
model = Status
fields = [
'uri',
'id',
'user',
'content',
'image'
]
class TaskSerializer(serializers.ModelSerializer):
user = UserPublicSerializer(read_only=True)
class Meta:
model = Task
fields = ['user', 'task', 'is_completed', 'timestamp', 'id']
read_only_fields = ['user']
def vaidate(self, data):
task = data.get('task', None)
if task == '':
task = None
if task is None:
raise serializers.ValidationError('Task cannot be empty.')
return data
class Meta:
model = FileSecureEntry
fields = [
'uri'
'File_ID',
'UserNameID',
'PersonNameID',
'File_Module',
'File_Image',
'File_CDate'
]
read_only_fields = ['UserNameID','File_ID','PersonNameID'] # Get calls its gone be read only.
uri = serializers.SerializerMethodField(read_only=True)
UserNameID = UserPublicSerializer(read_only=True)
class StatusSerializer(serializers.ModelSerializer):
user = UserPublicSerializer(read_only=True)
# userid = serializers.PrimaryKeyRelatedField(source='user', read_only=True)
# user_id = serializers.HyperlinkedRelatedField(
# source='user', # user foreign key
# lookup_field='username',
# view_name='api-user:detail',
# read_only=True
# )
# email = serializers.SlugRelatedField(source='user', read_only=True, slug_field='email')
uri = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Status
fields = [
'id',
'user',
# 'userid',
# 'user_id',
# 'email',
'content',
'image',
'uri'
]
read_only_fields = ['user'] # GET
# def validate_content(self, value):
# if len(value) > 10000:
# raise serializers.ValidationError("This is wayy too long.")
# return value
def get_uri(self, obj):
request = self.context.get('request')
return api_reverse('api-status:detail',
kwargs={"id": obj.id},
request=request)
def validate(self, data):
content = data.get("content", None)
if content == "":
content = None
image = data.get("image", None)
if content is None and image is None:
raise serializers.ValidationError("Content or image is required.")
return data
class StatusSerializer(serializers.ModelSerializer):
#for nesting serializer
#################################################
user = UserPublicSerializer(read_only=True)
uri = serializers.SerializerMethodField(read_only=True)
#user=serializers.SerializerMethodField(read_only=True)
#for serializer related field
#user_id=serializers.PrimaryKeyRelatedField(source='user', read_only=True)
# user_id=serializers.HyperlinkedRelatedField(source='user', lookup_field='username', view_name='api-user:detail', read_only=True)
# username=serializers.SlugRelatedField(source='user', read_only=True, slug_field='email')
################################################
class Meta:
model = Status
fields = ['id', 'user', 'content', 'image', 'uri']
read_only_fields = ['user'] #on GET calls user will be read only
# def get_user(self, obj):
# request=self.context.get('request')
# user=obj.user
# return UserPublicSerializer(user,read_only=True, context={"request":request}).data
def get_uri(self, obj):
#return "/api/status/{id}/".format(id=obj.id)
request = self.context.get('request')
return api_reverse('api-status:detail',
kwargs={'id': obj.id},
request=request)
# def validate_content(self, value):
# if len(value)>10000:
# raise serializers.ValidationError("This is way too long")
# return value
def validate(self, data):
content = data.get('content', None)
if content == "":
content = None
image = data.get('image', None)
if content is None and image is None:
raise serializers.ValidationError("Content or image is required")
return data
