fields = 'id', 'target_type', 'target_id'
class LikeViewSet(viewsets.ModelViewSet, QueryParamApiView):
queryset = Like.objects.all()
serializer_class = LikeSerializer
permission_classes = permissions.IsAuthenticated,
query_params = {
'target_type':
'target_content_type__model', # maybe 'post' or 'friendship'
'target': 'target_id'
}
def get_queryset(self):
qs = super(LikeViewSet, self).get_queryset()
post_id = self.request.query_params.get('post')
if post_id is not None:
qs = qs.filter(
Q(target_content_type=ContentType.objects.get_for_model(Post))
& Q(target_id=post_id))
return qs
def perform_create(self, serializer):
serializer.save(
author=self.request.user,
target_content_type=ContentType.objects.get_for_model(Post))
register('likes', LikeViewSet)
from rest_framework import serializers, viewsets, permissions
from .models import Friendship
from application.api import register
class FriendshipSerializer(serializers.ModelSerializer):
class Meta:
model = Friendship
fields = 'recipient', 'approved'
class FriendshipViewSet(viewsets.ModelViewSet):
queryset = Friendship.objects.all()
serializer_class = FriendshipSerializer
permission_classes = permissions.IsAuthenticated,
def perform_create(self, serializer):
serializer.save(author=self.request.user)
register('friendships', FriendshipViewSet)
"first_name",
"last_name",
"email",
"is_staff",
"is_active",
"date_joined",
"groups",
"user_permissions",
"achievements",
)
read_only_fields = ("password", "last_login", "is_superuser",
"is_staff", "is_active", "date_joined", "groups",
"user_permissions")
class UserViewSet(viewsets.ModelViewSet):
queryset = User.objects.all()
permission_classes = permissions.IsAuthenticated,
def get_serializer_class(self):
if self.suffix == u'List':
return UserSerializer
if self.get_object() == self.request.user:
return FullUserSerializer
else:
return UserSerializer
register('users', UserViewSet)
from core.api import UserSerializer
from application.api import register
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
class Meta:
model = Post
fields = 'id', 'text', 'title'
class PostViewSet(viewsets.ModelViewSet):
queryset = Post.objects.all()
serializer_class = PostSerializer
permission_classes = permissions.IsAuthenticated,
def get_queryset(self):
qs = super(PostViewSet, self).get_queryset()
if self.request.query_params.get('user'):
qs = qs.filter(author_id=self.request.query_params.get('user'))
return qs
def perform_create(self, serializer):
serializer.save(author=self.request.user)
register('posts', PostViewSet)
query_params = {'id': 'id', 'chat': 'chat_id', 'author': 'author_id'}
def get_queryset(self):
qs = super(MessageViewSet, self).get_queryset()
qs = qs.filter(
Q(author=self.request.user)
| Q(chat__participants=self.request.user))
qs = qs.distinct()
return qs
def perform_create(self, serializer):
serializer.save(author=self.request.user)
register('messages', MessageViewSet)
class ChatSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
last_message = serializers.SerializerMethodField()
def get_last_message(self, obj):
# print(obj.messages.all())
try:
return MessageSerializer(obj.messages.latest('created')).data
except:
return None
class Meta:
model = Chat
from rest_framework import serializers, viewsets, permissions
from rest_framework.reverse import reverse
from .models import CreationEvent
from application.api import register
class EventSerializer(serializers.ModelSerializer):
created_object = serializers.SerializerMethodField()
def get_created_object(self, obj):
viewname = '%s-detail' % obj.object_content_type.name
return reverse(viewname, (obj.object_id, ),
request=self.context['request'])
class Meta:
model = CreationEvent
fields = 'id', 'created_object'
class EventViewSet(viewsets.ModelViewSet):
queryset = CreationEvent.objects.all()
serializer_class = EventSerializer
permission_classes = permissions.IsAuthenticated,
http_method_names = ['get']
register('events', EventViewSet)