class NotificationSerializer(ModelSerializer):
"""Serializer class for notification."""
profile = ProfileSerializer()
class Meta:
model = Notification
fields = ('profile', 'message', 'status', 'category')
def get(self, request, *args, **kwargs):
"""
Get paginated post search results.
<BASE_URL>/<endpoint>/[..query_params]
Available query_params options:
1. page_number [int, default 1]
2. page_size [int, default 50]
3. search [str]
misco.com/profile/search/?search=martial%20arts&page_size=100
"""
page_number = request.query_params.get('page_number ', 1)
page_size = request.query_params.get('page_size ', 100)
search_token = request.query_params.get('search', None)
if not search_token:
raise Exception('Search Token not provided.')
profiles = Profile.objects.filter(
user__username__icontains=search_token) | Profile.objects.filter(
user__first_name=search_token) | Profile.objects.filter(
user__last_name=search_token)
paginator = Paginator(profiles, page_size)
serializer = ProfileSerializer(paginator.page(page_number),
many=True,
context={'request': request})
response = Response(serializer.data, status=status.HTTP_200_OK)
return response
def get_profile(self, obj):
if obj.user.profile:
data = ProfileSerializer(obj.user.profile).data
data["id"] = obj.user.id
del data["uuid"]
return data
else:
return {}
def get_receiver(self, obj):
try:
data = ProfileSerializer(obj.receiver.profile).data
data["id"] = obj.receiver.id
del data["uuid"]
return data
except:
return {}
class FavoritePostSerializer(ModelSerializer):
"""Serializer for favorite posts."""
post = PostSerializer()
profile = ProfileSerializer()
class Meta:
model = FavoritePost
fields = ('post', 'profile')
class FavoriteSoundSerializer(ModelSerializer):
"""Serializer for favorite songs."""
sound = SoundSerializer()
profile = ProfileSerializer()
class Meta:
model = FavoriteSound
fields = ('sound', 'profile')
class CommentSerializer(serializers.ModelSerializer):
"""Serializer class for comment model."""
post = PostSerializer()
profile = ProfileSerializer()
class Meta:
model = Comment
fields = ('post', 'profile', 'comment', 'created_at')
def get(self, request, *args, **kwargs):
"""Get profile view."""
serialized_profile = ProfileSerializer(request.user.profile,
context={'request': request})
return Response(data={
'profile': serialized_profile.data,
'is_self': True,
},
status=status.HTTP_200_OK)
class NestedCommentSerializer(serializers.ModelSerializer):
"""Serializer for comment class along with replies."""
profile = ProfileSerializer()
is_pointed_to = CommentSerializer(many=True)
likes = serializers.SerializerMethodField()
def get_likes(self, obj):
"""Return count of likes."""
return CommentLike.objects.filter(comment=obj).count()
class Meta:
model = Comment
fields = ('uuid', 'profile', 'comment', 'is_pointed_to', 'likes',
'created_at')
class PostSerializer(serializers.ModelSerializer):
"""Serializer for post model."""
profile = ProfileSerializer()
sound = SoundSerializer()
category = PostCategory()
likes = serializers.SerializerMethodField()
comments = serializers.SerializerMethodField()
shares = serializers.SerializerMethodField()
views = serializers.SerializerMethodField()
is_favorite = serializers.SerializerMethodField()
is_viewed = serializers.SerializerMethodField()
def get_is_favorite(self, obj):
request = self.context.get('request')
if not request:
return False
return is_post_favorite(request.user.profile, obj)
def get_is_viewed(self, obj):
request = self.context.get('request')
if not request:
return False
return is_post_favorite(request.user.profile, obj)
def get_likes(self, obj):
return likes_count(obj)
def get_comments(self, obj):
return comments_count(obj)
def get_shares(self, obj):
return share_count(obj)
def get_views(self, obj):
return post_views_count(obj)
class Meta:
model = Post
fields = ('uuid', 'profile', 'sound', 'video_file', 'video_gif',
'description', 'category', 'likes', 'shares', 'comments',
'views', 'is_favorite', 'is_downloadable', 'is_viewed')
class SoundSerializer(serializers.ModelSerializer):
"""Serializer for sound model."""
profile = ProfileSerializer()
category = SoundCategorySerializer()
views = serializers.SerializerMethodField()
is_favorite = serializers.SerializerMethodField()
def get_is_favorite(self, obj):
request = self.context.get('request')
if not request:
return False
return is_sound_favorite(request.user.profile, obj)
def get_views(self, obj):
return sound_views_count(obj)
class Meta:
model = Sound
fields = ('uuid', 'name', 'profile', 'sound_file', 'first_video',
'copyright', 'category', 'sound_cover', 'views',
'is_favorite')
def get(self, request, follow_tag):
"""
Get list of followers or following.
Available tag:
1. follower
2. following
"""
if follow_tag.lower() == 'follower':
uuid_list = FollowerMap.objects.filter(
following=request.user.profile).values_list('follower__uuid',
flat=True)
elif follow_tag.lower() == 'following':
uuid_list = FollowerMap.objects.filter(
follower=request.user.profile).values_list('following__uuid',
flat=True)
else:
raise Exception('Proper Tag was not passed.')
profiles = Profile.objects.filter(uuid__in=uuid_list)
serialized = ProfileSerializer(profiles,
many=True,
context={'request': request})
return Response(data=serialized.data, status=status.HTTP_200_OK)