from django.shortcuts import render from rest_framework import viewsets from rest_framework import permissions from .models import Post from .api import PostSerializer from application.api import router # Create your views here. 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 'author' in self.request.query_params: qs = qs.filter(author=self.request.query_params['author']) return qs def perform_create(self, serializer): serializer.save(author=self.request.user) router.register('posts', PostViewSet)
class PostSerializer(serializers.ModelSerializer): author = UserCutSerializer() class Meta: model = Post fields = 'author', 'content', 'pk', 'likes_count' class PostViewSet(viewsets.ModelViewSet): serializer_class = PostSerializer queryset = Post.objects.all() permission_classes = [ permissions.IsAuthenticated, IsOwnerOrReadOnly, IsFriend, ] def perform_create(self, serializer): serializer.save(author=self.request.user) def get_queryset(self): qs = super(PostViewSet, self).get_queryset()\ .filter(Q(author__in=self.request.user.friends.all()) | Q(author=self.request.user)) if 'author' in self.request.query_params: qs = qs.filter(author=self.request.query_params['author']) return qs router.register('post', PostViewSet, base_name='post') router.register('comment', CommentViewSet, base_name='comment')
def perform_create(self, serializer): serializer.save(author=self.request.user) def get_queryset(self): queryset = super(MessageViewSet, self).get_queryset() if 'chat' in self.request.query_params: if self.request.query_params['chat'].isdigit(): queryset = queryset.filter( chat=self.request.query_params['chat']) return queryset return queryset.filter(chat=0) class ChatUserViewSet(viewsets.ModelViewSet): queryset = ChatUser.objects.all() serializer_class = ChatUserSerializer def get_queryset(self): queryset = super(ChatUserViewSet, self).get_queryset() if 'chat' in self.request.query_params: if self.request.query_params['chat'].isdigit(): queryset = queryset.filter( chat=self.request.query_params['chat']) return queryset return queryset.filter(chat=0) router.register(r'chats', ChatViewSet) router.register(r'message', MessageViewSet) router.register(r'chatuser', ChatUserViewSet)
serializer.save(recipient=self.request.user, approved=True) def get_queryset(self): qs = super(FriendshipViewSet, self).get_queryset() if 'approved' in self.request.query_params: qs = qs.filter( approved=self.request.query_params['approved']).filter( recipient=self.request.user.id) return qs class FriendViewSet(viewsets.ModelViewSet): http_method_names = ['get', 'delete'] serializer_class = FriendSerializer queryset = Friend.objects.all() permission_classes = [ permissions.IsAuthenticated, IsFoobar, RestrictNotSafeAllowDelete ] def get_queryset(self): qs = super(FriendViewSet, self).get_queryset() if 'user' in self.request.query_params: qs = qs.filter(Q(foofriend_id=self.request.query_params['user'])) if 'mine' in self.request.query_params: qs = qs.filter(Q(foofriend_id=self.request.user)) return qs router.register('friendship', FriendshipViewSet) router.register('friend', FriendViewSet)
IsSafeMethod, ] def get_queryset(self): qs = super(EventViewSet, self).get_queryset().filter(content_type__in=CTYPES)\ .filter(event_type__modified=False)\ .filter(Q(author__in=self.request.user.friends.all()) | Q(author=self.request.user)) if 'user' in self.request.query_params: qs = qs.filter(author_id=self.request.query_params['user']) return qs class FeedbackViewSet(viewsets.ModelViewSet): serializer_class = EventSerializer queryset = Event.objects.all().filter(related_author_id__isnull=False) permission_classes = [ IsSafeMethod, ] def get_queryset(self): qs = super(FeedbackViewSet, self).get_queryset() qs = qs.filter(related_author=self.request.user) return qs router.register('feed', EventViewSet, base_name='feed') router.register('feedback', FeedbackViewSet, base_name='feedback')
def to_representation(self, value): if isinstance(value, Post): serializer = PostSerializer(value) else: raise Exception("Unexpected type of object") return serializer.data class LikeSerializer(serializers.ModelSerializer): author = UserSerializer target = ContentObjectRelatedField class Meta: model = Like fields = ['author', 'target'] class LikeViewSet(viewsets.ModelViewSet): queryset = Like.objects.all() serializer_class = LikeSerializer permission_classes = permissions.IsAuthenticated, def get_queryset(self): qs = super().get_queryset() if self.request.query_params.get('like'): qs = qs.filter(object_id=self.request.query_params.get('like')) return qs router.register(r'likes', LikeViewSet, 'likes')
from django.shortcuts import render from rest_framework import viewsets from rest_framework import permissions from .models import Event from .api import EventSerializer from application.api import router # Create your views here. class EventViewSet(viewsets.ModelViewSet): queryset = Event.objects.all() serializer_class = EventSerializer permission_classes = permissions.IsAuthenticated, def get_queryset(self): qs = super(EventViewSet, self).get_queryset() if 'author' in self.request.query_params: qs = qs.filter(author=self.request.query_params['author']) return qs def perform_create(self, serializer): serializer.save(author=self.request.user) router.register('events', EventViewSet)
class Meta: model = Friendship fields = ['friend', 'content'] def __null__(self): return None class FriendshipViewSet(viewsets.ModelViewSet): queryset = Friendship.objects.all() serializer_class = FriendshipSerializer permission_classes = (permissions.IsAuthenticated, ) def get_queryset(self): q = self.queryset username = self.request.query_params.get('username') if 'pk' in self.kwargs: pk = self.kwargs['pk'] q = q.filter(pk=pk) elif username: q = q.filter(username=username) else: q = q.filter(author=self.request.user) return q router.register('friendshiprequests', FriendshipRequestViewSet) router.register('friendship', FriendshipViewSet)
model = Event fields = ('id', 'author', 'created', 'title', 'content_object', 'content_type') # exclude = ('content_object',) depth = 0 def get_event_type(self, obj): # print(ContentTypeManager().get_for_model(obj), dir(ContentTypeManager().get_for_model(obj))) content_object_name = str(type(obj.content_object)).replace( '\'>', '').split('.') return content_object_name[len(content_object_name) - 1] class EventViewSet(viewsets.ReadOnlyModelViewSet): queryset = Event.objects.all() serializer_class = EventSerializer permission_classes = (permissions.IsAuthenticated, ReadOnly) def get_queryset(self): q = self.queryset q = q.filter(Q(author=self.request.user) | Q(author__friendship__friend=self.request.user))\ .distinct().order_by('-created') return q.prefetch_related('author', 'content_object') # def create(self, request, *args, **kwargs): # pass router.register('events', EventViewSet) router.register('achieve', AchieveViewSet)
class PostSearchSerializer(HaystackSerializer): def to_representation(self, instance): from .api import PostSerializer return PostSerializer(instance.object).to_representation(instance.object) class Meta: # The `index_classes` attribute is a list of which search indexes # we want to include in the search. index_classes = [PostIndex] # The `fields` contains all the fields we want to include. # NOTE: Make sure you don't confuse these with model attributes. These # fields belong to the search index! fields = [ "text", "title" ] class PostSearchView(HaystackViewSet): # `index_models` is an optional list of which models you would like to include # in the search result. You might have several models indexed, and this provides # a way to filter out those of no interest for this particular view. # (Translates to `SearchQuerySet().models(*index_models)` behind the scenes. index_models = [Post] serializer_class = PostSearchSerializer router.register('posts/search', PostSearchView, base_name='posts-search')
from django.shortcuts import render from rest_framework import viewsets from rest_framework import permissions from .api import UserSerializer from .permissions import IsOwnerOrReadOnly from application.api import router from django.contrib.auth import get_user_model # Create your views here. class UserViewSet(viewsets.ModelViewSet): queryset = get_user_model().objects.all() serializer_class = UserSerializer permission_classes = (permissions.IsAuthenticated, IsOwnerOrReadOnly, ) router.register('users', UserViewSet) def home(request): return render(request, 'home.html')
serializer_class = RequestSerializer permission_classes = permissions.IsAuthenticated, RequestPermission, def get_queryset(self): qs = super(RequestViewSet, self).get_queryset() if 'author' in self.request.query_params: qs = qs.filter(author=self.request.query_params['author']) if 'recipient' in self.request.query_params: qs = qs.filter(recipient=self.request.query_params['recipient']) return qs def perform_create(self, serializer): serializer.save(author=self.request.user) router.register('requests', RequestViewSet) class FriendShipViewSet(viewsets.ModelViewSet): queryset = FriendShip.objects.all() serializer_class = FriendShipSerializer permission_classes = permissions.IsAuthenticated, def get_queryset(self): qs = super(FriendShipViewSet, self).get_queryset() if 'user' in self.request.query_params: qs = qs.filter(first=self.request.query_params['user']) return qs def perform_create(self, serializer): serializer.save(first=self.request.user)
# Create your views here. from drf_haystack.viewsets import HaystackViewSet from application.api import router from .models import Message from .search_api import MessageSearchSerializer class PostSearchView(HaystackViewSet): index_models = [Message] serializer_class = MessageSearchSerializer router.register('messages/search', PostSearchView, base_name='messages-search')
serializer_class = ChatSerializer def get_serializer_class(self): serializer_class = super(ChatViewSet, self).get_serializer_class() if self.request.method in ['POST', 'PUT', 'PATCH']: return ChatCreateSerializer else: return serializer_class def get_queryset(self): return Chat.objects.all().filter(users=self.request.user) class MessageViewSet(viewsets.ModelViewSet): serializer_class = MessageSerializer queryset = Message.objects.all() permission_classes = [ IsChatParticipant, IsAuthenticated, ] def get_queryset(self): qs = super(MessageViewSet, self).get_queryset() qs = qs.filter(chat__users=self.request.user) return qs router.register('chat', ChatViewSet, 'chat') router.register('message', MessageViewSet, 'message')
class MessagePagination(PageNumberPagination): page_size = 50 page_size_query_param = 'page_size' max_page_size = 200 class MessageViewSet(viewsets.ModelViewSet): queryset = Message.objects.all() serializer_class = MessageSerializer permission_classes = (permissions.IsAuthenticated, ) pagination_class = MessagePagination def perform_create(self, serializer): serializer.save(author=self.request.user) def get_queryset(self): q = self.queryset.filter(chat__chats__user=self.request.user) chat_id = self.request.query_params.get('chat') if chat_id: q = q.filter(chat__id=chat_id) return q.prefetch_related('chat') # def get_serializer_context(self): # context = super(MessageViewSet, self).get_serializer_context() # context['author'] = self.request.user # return context router.register('chats', ChatViewSet) router.register('userchats', UserChatViewSet) router.register('messages', MessageViewSet)
if attrs['password'] != attrs['repeat_password']: raise serializers.ValidationError('PasswordsDoNotMatch') return attrs def create(self, validated_data): user = User.objects.create_user( username=validated_data['username'], email=validated_data['email'], ) user.set_password(validated_data['password']) user.save() return user class UserViewSet(viewsets.ModelViewSet): serializer_class = UserSerializer queryset = User.objects.all() permission_classes = [ OwnerOrSafeMethods, ] def get_serializer_class(self): serializer_class = self.serializer_class if self.request.method in ['POST', 'PUT', 'PATCH']: serializer_class = UserCreateSerializer return serializer_class router.register('user', UserViewSet, base_name='user')
from django.contrib.contenttypes.models import ContentType from core.api import UserSerializer class LikeSerializer(serializers.ModelSerializer): class Meta: model = Like fields = ('author', 'object_id', 'content_type') class LikeViewSet(viewsets.ModelViewSet): queryset = Like.objects.all() serializer_class = LikeSerializer # permission_classes = (permissions.IsAuthenticated, IsOwnerOrReadOnly) permission_classes = (permissions.IsAuthenticated, ) def perform_create(self, serializer): serializer.save(author=self.request.user, approved=False) def get_queryset(self): q = super(LikeViewSet, self).get_queryset() post_id = self.request.query_params.get('post') if post_id: q = q.filter( Q(object_id=post_id) & Q(content_type=ContentType.objects.get_for_model(Post))) return q router.register('likes', LikeViewSet)
def get_queryset(self): qs = super().get_queryset().select_related('author') if self.request.query_params.get('user') and \ Subscription.objects.filter(author=self.request.user, target=self.request.query_params.get('user')).exists(): qs = qs.filter(author=self.request.query_params.get('user')) else: qs = qs.filter(author=self.request.user) return qs class CommentViewSet(viewsets.ModelViewSet): queryset = Comment.objects.all() serializer_class = CommentSerializer def perform_create(self, serializer): serializer.save(author=self.request.user) def get_queryset(self): qs = super().get_queryset().select_related('target') if 'post' in self.request.query_params: qs = qs.filter(target=self.request.query_params['post']) else: qs.none() return qs router.register(r'posts', PostViewSet, 'posts') router.register(r'comments', CommentViewSet, 'comments')