class BarkSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(source='user.profile', read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
parent = BarkCreateSerializer(read_only=True)
class Meta:
model = Bark
fields = [
'user', 'id', 'content', 'likes', 'is_rebark', '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 TweetCreateSerializer(serializers.ModelSerializer):
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 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)
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 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 Nash_messageCreateSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(
source='user.profile',
read_only=True) # serializers.SerializerMethodField(read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Nash_message
fields = ['user', 'id', 'content', 'likes', 'timestamp']
def get_likes(self, obj):
return obj.likes.count()
def validate_content(self, value):
if len(value) > MAX_NASH_MESSAGE_LENGTH:
raise serializers.ValidationError("This nash_message is too long")
return value
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 TweetSerializer(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 = ['user','id','content','likes','is_retweet','parent','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 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 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 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 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')
class NogginCreateSerializer(serializers.ModelSerializer):
user = PublicProfileSerializer(
source='user.profile',
read_only=True) # serializers.SerializerMethodField(read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
image = Base64ImageField(max_length=None, use_url=True, required=False)
video = Base64Field(max_length=None, use_url=True, required=False)
timestamp = serializers.DateTimeField(format="%m-%d-%Y%H:%M:%S",
required=False,
read_only=True)
class Meta:
model = Noggin
fields = [
'user', 'id', 'content', 'image', 'video', 'likes', 'timestamp'
]
def get_likes(self, obj):
return obj.likes.count()
def validate_content(self, value):
if len(value) > NOGGIN_FULL:
raise serializers.ValidationError("this Noggin is too Long")
return value
def get_less_students(self, container):
students = container.students.all()[:12]
serializer = PublicProfileSerializer(instance=students, many=True)
return serializer.data
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 ResourceBaseSerializer(serializers.ModelSerializer):
metadata = ResourceMetaDataSerializer(many=False, required=False)
sections = TextBookChapterSerializer(many=True)
owner = PublicProfileSerializer(read_only=True)
def create(self, validated_data):
metadata_data = validated_data.pop('metadata')
sections = validated_data.pop('sections')
if metadata_data:
try:
validated_data['title'] = metadata_data['data']['volumeInfo'][
'title']
except:
pass
instance = super(ResourceBaseSerializer, self).create(validated_data)
# TODO need to check that at least one solution exists
if instance.resource_type == 'TB':
# add TextBook Resource type sections
sections_objects = []
for i, section in enumerate(sections):
sections_objects.append(
TextBookChapter(resource=instance,
title=section['title'],
position=i))
saved_sections = TextBookChapter.objects.bulk_create(
sections_objects)
for saved_section in saved_sections:
section_data = sections[saved_section.position]
if 'problems' in section_data:
problems_objects = []
for i, problem in enumerate(section_data['problems']):
problems_objects.append(
TextBookProblem(textbook_section=saved_section,
title=problem['title'],
position=i))
# save problems
saved_problems = TextBookProblem.objects.bulk_create(
problems_objects)
for saved_problem in saved_problems:
problem_data = section_data['problems'][
saved_problem.position]
if 'solutions' in problem_data:
solutions_objects = []
for y, solution in enumerate(
problem_data['solutions']):
solutions_objects.append(
TextBookSolution(
pdf_id=solution['pdf']['id'],
position=y,
textbook_problem=saved_problem,
posted_by=validated_data['owner']))
# save solutions
TextBookSolution.objects.bulk_create(
solutions_objects)
ResourceMetaData.objects.create(resource=instance, **metadata_data)
return instance
class Meta:
model = Resource
fields = [
'uuid', 'created_on', 'updated_on', 'resource_type', 'metadata',
'sections', 'count_views', 'owner', 'thread'
]
read_only_fields = ('uuid', 'created_on', 'updated_on', 'count_views',
'thread')
class UserDetailSerializer(ModelSerializer):
profile = PublicProfileSerializer(read_only=True)
uri = SerializerMethodField(read_only=True)
posts = SerializerMethodField(read_only=True)
followers = SerializerMethodField(read_only=True)
followings = SerializerMethodField(read_only=True)
friends = SerializerMethodField(read_only=True)
class Meta:
model = User
fields = [
'id',
'username',
'uri',
'profile',
'posts',
'followers',
'followings',
'friends',
]
def get_uri(self, obj):
request = self.context.get('request')
return api_reverse("api-user:detail",
kwargs={"username": obj.username},
request=request)
def get_posts(self, obj):
request = self.context.get('request')
limit = 10
if request:
limit_query = request.GET.get('posts_limit')
try:
limit = int(limit_query)
except:
pass
qs1 = obj.post_set.all().order_by("-timestamp")
user_following = obj.followings.all()
followings = user_following.exclude(user=obj)
users = []
for following in followings:
user = get_object_or_404(User, username=following.user.username)
users.append(user)
qs2 = Post.objects.filter(user__in=users)
qs = (qs1 | qs2).distinct().order_by("-timestamp")
data = {
'total':
obj.post_set.all().count(),
'uri':
self.get_uri(obj) + "posts/",
'last':
PostInlineSerializer(qs.first(), context={
'request': request
}).data,
'recent':
PostInlineSerializer(qs[:limit],
many=True,
context={
'request': request
}).data
}
return data
def get_followers(self, obj):
request = self.context.get('request')
limit = 10
if request:
limit_query = request.GET.get('followers_limit')
try:
limit = int(limit_query)
except:
pass
try:
follower_obj = get_object_or_404(Followers, user=obj)
# Have to exclude the user from his or her followers
followers = follower_obj.followers.all() #.exclude(user=obj)
except:
pass
try:
data = {
'total':
followers.count(),
'uri':
self.get_uri(obj) + "followers/",
'last':
FollowersSerializer(followers.first(),
context={
'request': request
}).data,
'recent':
FollowersSerializer(followers[:limit],
many=True,
context={
'request': request
}).data
}
except:
data = "No followers yet."
return data
def get_followings(self, obj):
request = self.context.get('request')
limit = 10
if request:
limit_query = request.GET.get('followings_limit')
try:
limit = int(limit_query)
except:
pass
try:
follower_obj = get_object_or_404(Followers, user=obj)
followings = follower_obj.user.followings.all()
except:
pass
try:
data = {
'total':
followings.count(),
'uri':
self.get_uri(obj) + "followings/",
'last':
FollowingsSerializer(followings.first(),
context={
'request': request
}).data,
'recent':
FollowingsSerializer(followings[:limit],
many=True,
context={
'request': request
}).data
}
except:
data = "No followings yet."
return data
def get_friends(self, obj):
request = self.context.get('request')
limit = 10
if request:
limit_query = request.GET.get('friends_limit')
try:
limit = int(limit_query)
except:
pass
try:
friends_obj = get_object_or_404(Friends, user=obj)
friends = friends_obj.friends.all()
except:
pass
try:
data = {
'total':
friends.count(),
'uri':
self.get_uri(obj) + "friends/",
'last':
FriendsSerializer(friends.first(),
context={
'request': request
}).data,
'recent':
FriendsSerializer(friends[:limit],
many=True,
context={
'request': request
}).data
}
except:
data = "No friends yet."
return data
