class FilletCreateSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
like_count = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Fillet
fields = [
'id',
'text',
'user',
'like_count',
'timestamp',
]
def get_like_count(self, obj):
return obj.likes.count()
def validate_text(self, value):
if len(value) > settings.MAX_FILLET_LENGTH:
raise serializers.ValidationError(
f"Fillets can't be longer than {settings.MAX_FILLET_LENGTH} characters."
)
if not value.strip():
raise serializers.ValidationError("Fillets cannot be empty.")
self.censor_text(value)
return value
@staticmethod
def censor_text(text):
for bad_word in settings.BAD_WORDS:
if bad_word in text.lower():
raise serializers.ValidationError(
f"Fillets cannot contain forbidden word '{bad_word.title()}'. Please be polite!"
)
def paginated_user_response(qs, request):
paginator = PageNumberPagination()
paginator.page_size = 20
paginated_qs = paginator.paginate_queryset(qs, request)
serializer = PublicProfileSerializer(paginated_qs, many=True)
return paginator.get_paginated_response(
serializer.data) # Response( serializer.data, status=200)
class TweetSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
parent = TweetCreateSerializer(read_only=True)
community = serializers.SerializerMethodField(read_only=True)
hash_tag = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Tweet
fields = [
'user', 'id', 'content', 'likes', 'is_retweet', 'parent',
'timestamp', 'community', 'hash_tag', 'image', 'timestamp'
]
def get_likes(self, obj):
return obj.likes.count()
def get_community(self, obj):
community = Community.objects.filter(tweet=obj)
serializer = CommunitySerializer(community, many=True)
return serializer.data
def get_hash_tag(self, obj):
hash_tag = HashTag.objects.filter(tweet=obj)
serializer = HashTagSerializer(hash_tag, many=True)
return serializer.data
class TweetCreateSerializer(serializers.ModelSerializer): user = PublicProfileSerializer(source='user.profile', read_only=True) #serializers.SerializerMethodField(read_only=True) likes = serializers.SerializerMethodField(read_only=True) class Meta: model=Tweet fields='__all__' def get_likes(self, obj): return obj.likes.count()
def get_paginated_queryset_recommend_user_response(query_set, request):
paginator = PageNumberPagination()
paginator.page_size = 3
paginated_qs = paginator.paginate_queryset(query_set, request)
serializer = PublicProfileSerializer(paginated_qs,
many=True,
context={"request": request})
return paginator.get_paginated_response(serializer.data)
class CurriculumSerializer(ExpanderSerializerMixin, BaseSerializer):
units = UnitSerializer(many=True, read_only=True)
author = UserSerializer(read_only=True)
collaborators = PublicProfileSerializer(many=True, read_only=True)
collaborators_ids = serializers.SlugRelatedField(
queryset=Profile.objects.all(),
source='collaborators',
slug_field='id',
many=True,
write_only=True)
count_lessons = serializers.IntegerField(read_only=True)
number_of_learners = serializers.IntegerField(
read_only=True, source='number_of_learners_denormalized')
def validate_name(self, value):
if value and value.lower() == Curriculum.Name.DEFAULT.lower():
raise serializers.ValidationError("Invalid name: %s" % value)
return value
def validate_cover_photo(self, value):
w, h = get_image_dimensions(value)
if value:
if round(w / h, 1) != 2.7:
raise serializers.ValidationError(
"Invalid aspect ratio (2.7 : 1)")
return value
def update(self, instance, validated_data):
# TODO Do we need to save collaborators while create curriculum?
try:
instance.collaborators = validated_data.pop('collaborators')
except KeyError:
pass
if 'name' in validated_data and self.instance.name == Curriculum.Name.DEFAULT:
del validated_data['name']
return super().update(instance, validated_data)
class Meta:
model = Curriculum
list_serializer_class = DictSerializer
fields = [
'uuid', 'name', 'image', 'url', 'units', 'created_on',
'updated_on', 'count_lessons', 'author', 'cover_photo',
'number_of_learners', 'description', 'collaborators',
'collaborators_ids', 'setting_units_unlocked',
'setting_modules_unlocked', 'setting_lessons_unlocked',
'setting_publically'
]
read_only_fields = ('uuid', 'units', 'created_on', 'updated_on')
expandable_fields = {
'units': (UnitSerializer, (), {
'many': True
}),
}
extra_kwargs = {'url': {'lookup_field': 'uuid'}}
class TweetCreateSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True) # serializers.SerializerMethodField(read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Tweet
fields = ['user', 'id', 'content', 'likes', 'timestamp']
def get_likes(self, obj):
return obj.likes.count()
class EntrySerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
post_entry = EntryCreateSerializer(many=True, read_only=True)
class Meta:
model = Topic
fields = ['id', 'post_topic', 'post_entry', 'user']
def get_post_topic(self, obj):
return obj.post_topic
class TweetCreateSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
class Meta:
model = Tweet
fields = ['user', 'id', 'content', 'timestamp']
def validate_content(self, value):
if len(value) > MAX_TWEET_LENGTH:
raise serializers.ValidationError("This tweet is too long!")
return value
class CommentCreateSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
tweet = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Tweet
fields = '__all__'
def validate_content(self, value):
if len(value) > MAX_TWEET_LENGTH:
raise serializers.ValidationError("This tweet is too long!")
return value
class TopicSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
post_topic = serializers.SerializerMethodField(read_only=True)
post_entry = serializers.SlugRelatedField(many=True,
read_only=True,
slug_field='post_entry')
class Meta:
model = Topic
fields = ['user', 'id', 'post_topic', 'post_entry']
def get_post_topic(self, obj):
return obj.post_topic
class TweetCreateSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True) # serializers.SerializerMethodField(read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Tweet
fields = ['user', 'id', 'content', 'likes', 'timestamp']
def get_likes(self,obj):
return obj.likes.count()
def validate_content(self, value):
if len(value) > MAX_TWEET_LENGTH:
raise serializers.ValidationError("This tweet is too long")
return value
class TopicCreateSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
post_entry = serializers.SlugRelatedField(many=True,
read_only=True,
slug_field='post_entry')
class Meta:
model = Topic
fields = ['user', 'id', 'post_topic', 'post_entry']
def validate_post_topic(self, value):
if len(value) > MAX_TITLE_LENGTH:
raise serializers.ValidationError("This title is too long")
return value
class Nash_messageSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
parent = Nash_messageCreateSerializer(read_only=True)
class Meta:
model = Nash_message
fields = [
'user', 'id', 'content', 'likes', 'is_renash', 'parent',
'timestamp'
]
def get_likes(self, obj):
return obj.likes.count()
class TweetSerializerLikes(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
parent = TweetCreateSerializer(read_only=True)
class Meta:
model=Tweet
fields='__all__'
def get_likes(self, obj):
# print(obj.user)
# print(type(obj))
# print(user_likes, user)
# users_who_like = obj.likes.values_list('username', flat=True)
# user_followers = user.profile.followers.values_list('username', flat=True)
# print(users_who_like, user_followers)
return obj.likes.values_list('username', flat=True)
class TextBookSolutionSerializer(serializers.ModelSerializer):
pdf = TextBookSolutionPDFSerializer(
many=False,
required=False # we can set existing pdf solution
)
posted_by = PublicProfileSerializer(read_only=True)
# title = serializers.SerializerMethodField()
title = serializers.CharField(required=False)
pdf_id = serializers.PrimaryKeyRelatedField(
queryset=TextBookSolutionPDF.objects.all(),
source='pdf',
many=False,
write_only=True,
required=False # we can set existing pdf solution
)
textbook_problem_uuid = serializers.SlugRelatedField(
queryset=TextBookProblem.objects.all(),
source='textbook_problem',
slug_field='uuid',
many=False,
# write_only=True,
required=False # we can set existing textbook_problem
)
count_comments = serializers.SerializerMethodField()
def get_count_comments(self, obj):
count_comments = 0
if hasattr(obj, 'thread') and obj.thread:
count_comments = obj.thread.op.get_descendant_count()
return count_comments
# def get_title(self, obj):
# return obj.title
class Meta:
model = TextBookSolution
fields = [
'pdf', 'posted_by', 'id', 'position', 'title', 'created_on',
'uuid', 'vote_score', 'thread', 'textbook_problem_uuid', 'pdf_id',
'count_comments'
]
read_only_fields = ('id', 'created_on', 'uuid', 'vote_score', 'pdf',
'thread')
extra_kwargs = {'position': {'required': False}}
class TweetSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(
source='user.profile',
read_only=True) #serializers.SerializerMethodField(read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
parent = TweetCreateSerializer(read_only=True)
class Meta:
model = Tweet
fields = [
"user", "id", "content", "likes", "is_retweet", "parent",
"timestamp"
]
def get_likes(self, obj):
return obj.likes.count()
class TweetCreateSerializer(serializers.ModelSerializer):
# user = serializers.SerializerMethodField(read_only=True)
user = PublicProfileSerializer(source="user.profile", read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Tweet
fields = ["user", "id", "content", "likes", "timestamp"]
def get_likes(self, obj):
return obj.likes.count()
def validate_content(self, value):
if len(value) > MAX_TWEET_LENGTH:
raise serializers.ValidationError("This Tweet is too long")
return value
class PostSerializer(serializers.ModelSerializer):
created_by = PublicProfileSerializer(source='created_by.profile',
read_only=True)
# mardown_content = serializers.SerializerMethodField()
#
# def get_mardown_content(self, obj):
# return markdown_deux.markdown(obj.content, 'default')
class Meta:
fields = [
'uid', 'content', 'created_by', 'created_on', 'parent',
'modified_on', 'level', 'score'
]
read_only_fields = ('level', )
model = Post
class BarkCreateSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Bark
fields = ['user', 'id', 'content', 'likes', 'timestamp']
def get_likes(self, obj):
return obj.likes.count()
def validate_content(self, value):
if len(value) > MAX_BARK_LENGTH:
raise serializers.ValidationError(
"This bark is too long. Please limit barks to 240 characters")
return value
class TweetSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
parent = TweetCreateSerializer(read_only=True)
# is_retweet = serializers.SerializerMethodField(read_only=True) - no need to call, when is a class property
class Meta:
model = Tweet
fields = [
'user', 'id', 'content', 'likes', 'is_retweet', 'parent',
'timestamp'
]
def get_likes(self, obj):
return obj.likes.count()
class TweetSerializers(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True) #user = serializers.SerializerMethodField(read_only=True) # added so that we can know which user posted which tweet when 94
likes = serializers.SerializerMethodField(read_only=True)
# content = serializers.SerializerMethodField(read_only=True)
# is_retweet = serializers.SerializerMethodField(read_only=True)
# we don't actually need to call a serializer method again for a property that is on the object itself
parent = TweetCreateSerializers(read_only=True)
class Meta:
model = Tweet
fields = ['user', 'id', 'content', 'likes', 'is_retweet', 'parent', 'timestamp']
def get_likes(self, obj):
return obj.likes.count()
# def get_user(self, obj): # added newly for user identification of tweets
# return obj.user.id
'''def get_content(self, obj):
class FilletSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
like_count = serializers.SerializerMethodField(read_only=True)
parent = FilletCreateSerializer(read_only=True)
class Meta:
model = Fillet
fields = [
'id',
'text',
'user',
'like_count',
'timestamp',
'is_repost',
'parent',
]
def get_like_count(self, obj):
return obj.likes.count()
class TweetReadSerializer(serializers.ModelSerializer):
author = PublicProfileSerializer(source='author.profile', read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
og_tweet = TweetCreateSerializer(source='parent', read_only=True)
class Meta:
model = Tweet
fields = ['author', 'id', 'content', 'likes',
'is_retweet', 'og_tweet', 'timestamp']
def get_likes(self, obj):
return obj.likes.count()
def get_content(self, obj):
content = obj.content
if obj.is_retweet:
content = obj.parent.content
return content
class TweetCreateSerializer(serializers.ModelSerializer
): # <- this is for the create view
user = PublicProfileSerializer(
source="user.profile",
read_only=True) #serializers.SerializerMethodField(read_only=True)
likes = serializers.SerializerMethodField(
read_only=True) # I just want it to be numbers
class Meta:
model = Tweet
fields = ['user', 'id', 'content', 'likes', 'timestamp']
def get_likes(self, obj):
return obj.likes.count()
def validate_content(self, value):
if len(value) > MAX_TWEET_LENGTH:
raise serializers.ValidationError(
"This tweet is too long! Max limit 240 charaters.")
return value
class TweetSerializer(serializers.ModelSerializer
): # This is read only for the retweeting action
user = PublicProfileSerializer(
source="user.profile", read_only=True
) #user = serializers.SerializerMethodField(read_only=True)
likes = serializers.SerializerMethodField(
read_only=True) # I just want it to be numbers
# content = serializers.SerializerMethodField(read_only=True)
# No need to call a serializer method again for a property in the serializers.py since it is in the object itself
parent = TweetCreateSerializer(read_only=True)
class Meta:
model = Tweet
fields = [
'user', 'id', 'content', 'likes', 'is_retweet', 'parent',
'timestamp'
]
def get_likes(self, obj):
return obj.likes.count()
class TweetCreateSerializer(serializers.ModelSerializer):
author = PublicProfileSerializer(source='user.profile', read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
timestamp = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Tweet
fields = ['author', 'id', 'content', 'likes', 'timestamp']
def get_likes(self, obj):
return obj.likes.count()
def get_timestamp(self, obj):
return obj.timestamp
def validate_content(self, value):
if len(value) > settings.MAX_TWEET_LENGTH:
raise serializers.ValidationError(
'Maximum of 180 characters in one tweet.')
return value
class NogginSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
comments = serializers.SerializerMethodField(source='noggin.Comment',
read_only=True)
eyeballs = serializers.SerializerMethodField(source='noggin.NogginEyeball',
read_only=True)
parent = NogginCreateSerializer(read_only=True)
image = Base64ImageField(max_length=None, use_url=True, required=False)
video = serializers.FileField(max_length=None,
use_url=True,
required=False)
timestamp = serializers.DateTimeField(format="%m-%d-%Y %H:%M",
required=False,
read_only=True)
class Meta:
model = Noggin
fields = [
'comments', 'eyeballs', 'user', 'id', 'content', 'likes', 'image',
'video', 'parent', 'timestamp'
]
def get_eyeballs(self, obj):
return obj.eyeball_count.count()
def get_comments(self, obj):
return obj.comments.count()
def get_likes(self, obj):
return obj.likes.count()
def get_content(self, obj):
return obj.parent.content
def get_image(self, obj):
return obj.parent.image
def get_video(self, obj):
return obj.parent.video
class TweetSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
#user = serializers.SerializerMethodField(read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
#content = serializers.SerializerMethodField(read_only=True)
#is_retweet = serializers.SerializerMethodField(read_only=True) #DONT NEED TO CALL serliazerMethod for a property on the object itself.
parent = TweetCreateSerializer(read_only=True)
class Meta:
model = Tweet
fields = [
'user',
'id',
'content',
'likes',
'is_retweet',
'parent',
#'timestamp'
]
def get_likes(self, obj):
return obj.likes.count()
class ClassroomBaseSerializer(serializers.ModelSerializer):
count_students = serializers.IntegerField(read_only=True)
teacher = PublicProfileSerializer(read_only=True)
curriculum = CurriculumSerializer(read_only=True)
# curriculum = SimpleCurriculumSerializer(read_only=True)
curriculum_uuid = serializers.SlugRelatedField(queryset=Curriculum.objects.all(), source='curriculum',
slug_field='uuid', write_only=True)
external_classroom = ExternalClassroomSerializer(many=False, required=False)
def create(self, validated_data):
external_classroom = None
if 'external_classroom' in validated_data:
external_classroom = validated_data.pop('external_classroom')
to_return = super(ClassroomBaseSerializer, self).create(validated_data)
if external_classroom:
# save external data
kwargs = external_classroom
# if 'provider' in external_classroom:
# kwargs['provider'] = external_classroom.pop('provider')
# external_id=external_classroom['external_id'],
# name=external_classroom['name'],
# teacher_id=external_classroom['teacher_id'],
# code=external_classroom['code'],
try:
ExternalClassroom.objects.create(classroom=to_return,
**kwargs)
except: # TODO raise error message
pass
return to_return
class Meta:
model = Classroom
fields = ['uuid', 'name', 'created_on', 'updated_on', 'curriculum', 'code', 'count_students',
'teacher', 'curriculum_uuid', 'external_classroom']
read_only_fields = ('uuid', 'code', 'created_on', 'updated_on')