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')
