puckoprutt-web-api/user_profile/views.py

from django.shortcuts import render
from settings.puckoviews import PuckoView, PuckoPaginatedView, PuckoSearchView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated

from settings.puckolizers import Message_Serializer
from user_profile.models import User_Profile
from user_profile.models import Friend_Request
from user_profile.serializer import Friend_Request_Serializer
from user_profile.serializer import User_Profile_Small_Serializer
from user_profile.serializer import User_Profile_Serializer
from user_profile.serializer import My_Profile_Serializer
from user_profile.serializer import User_Searchalizer

class My_Profile_View(PuckoView):
    permission_classes = [IsAuthenticated,]
    serializer_class = My_Profile_Serializer
    model_class = User_Profile

    def my_profile(self, request):
        profile = request.user.profile
        serializer = self.serializer_class(profile)
        return Response(serializer.data, status=200)

    def update(self, request):
        obj = request.user.profile
        serializer = self.serializer_class(obj, data=request.data, partial=False)
        if serializer.is_valid(raise_exception=True):
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)

    def update_partial(self, request):
        obj = request.user.profile
        serializer = self.serializer_class(obj, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)
    
class My_Friends_View(PuckoPaginatedView):
    permission_classes = (IsAuthenticated,)
    serializer_class = User_Profile_Small_Serializer
    model_class = User_Profile

    def get_queryset(self, request=None):
        return request.user.profile.friends.all()
    
class User_Search_View(PuckoSearchView):
    permission_classes = [IsAuthenticated,]
    serializer_class = User_Searchalizer
    model_class = User_Profile

    def get_object(self, data):
        try:
            ret = self.model_class.search_for(query=data["search"])
        except Exception:
            ret = None
        return ret
    
class User_Profile_View(PuckoView):
    permission_classes = [IsAuthenticated,]
    serializer_class = User_Profile_Serializer
    model_class = User_Profile

    def profile(self, request, slug):
        try:
            obj = User_Profile.objects.get(slug=slug)
        except:
            serializer = Message_Serializer({"message": "user not found"})
            return Response(serializer.data, status=404)
        serializer = self.serializer_class(obj, many=False)
        return Response(serializer.data, status=200)
        
class Send_Friend_Request_View(PuckoView):
    permission_classes = [IsAuthenticated,]
    serializer_class = Message_Serializer
    model_class = Friend_Request

    def send(self, request, slug):
        user = request.user.profile
        try:
            friend = User_Profile.objects.get(slug=slug)
        except Exception:
            serializer = Message_Serializer({"message": "user not found"})
            return Response(serializer.data, status=404)
        if friend == user:
            serializer = Message_Serializer({"message": "no need to befriend yourself, duuh"})
        else:
            serializer = self.serializer_class({"message": user.friend_request_send(friend)})
        return Response(serializer.data, status=200)

    
class Friend_Requests_Sent_View(PuckoPaginatedView):
    permission_classes = (IsAuthenticated,)
    serializer_class = Friend_Request_Serializer
    model_class = Friend_Request

    def get_queryset(self, request=None):
        return request.user.profile.friend_requests_sent.all()
    
class Friend_Request_Recieved_Slug_View(PuckoView):
    permission_classes = (IsAuthenticated,)
    serializer_class = Message_Serializer
    model_class = User_Profile

    def deny(self, request, friend_request_id):
        """Deny a friend request
        """
        if not Friend_Request.objects.filter(pk=friend_request_id, to_user=request.user.profile.pk).exists():
            serializer = self.serializer_class({"message": "Unknown friend request."})
            return Response(serializer.data, status=404)
        req = Friend_Request.objects.get(pk=friend_request_id)
        message = f"friend request from {req.from_user} have been denied."
        if request.user.profile.friend_request_deny(friend_request_id):
            serializer = self.serializer_class({"message": "Could not deny friend request."})
            return Response(serializer.data, status=403)
        serializer = self.serializer_class({"message": message})
        return Response(serializer.data, status=204)

    def accept(self, request, friend_request_id):
        """Accept a friend request
        """
        if not Friend_Request.objects.filter(pk=friend_request_id, to_user=request.user.profile.pk).exists():
            serializer = self.serializer_class({"message": "Unknown friend request."})
            return Response(serializer.data, status=404)
        new_friend = Friend_Request.objects.get(pk=friend_request_id, to_user=request.user.profile.pk).from_user
        if request.user.profile.friend_request_accept(friend_request_id):
            serializer = self.serializer_class({"message": "Could not accept friend request."})
            return Response(serializer.data, status=403)
        return Response({"message": f"You are now friends with {new_friend.nickname}"}, status=200)


class Friend_Requests_Recieved_View(PuckoPaginatedView):
    permission_classes = (IsAuthenticated,)
    serializer_class = Friend_Request_Serializer
    model_class = Friend_Request

    def get_queryset(self, request=None):
        return request.user.profile.friend_requests_recieved.all()
    
class Friend_Request_Sent_Slug_View(PuckoView):
    permission_classes = (IsAuthenticated,)
    serializer_class = Message_Serializer
    model_class = User_Profile

    def destroy(self, request, friend_request_id):
        """Delete a sent friend request
        """
        if not Friend_Request.objects.filter(pk=friend_request_id, from_user=request.user.profile.pk).exists():
            serializer = self.serializer_class({"message": "Unknown friend request."})
            return Response(serializer.data, status=404)
        req = Friend_Request.objects.get(pk=friend_request_id)
        message = f"friend request to {req.to_user} have been removed."
        req.delete()
        serializer = self.serializer_class({"message": message})
        return Response(serializer.data, status=204)