132 lines
4.9 KiB
Python
132 lines
4.9 KiB
Python
from knox.auth import TokenAuthentication
|
|
from rest_framework.viewsets import GenericViewSet
|
|
from rest_framework.generics import GenericAPIView
|
|
from rest_framework.response import Response
|
|
from rest_framework.viewsets import ViewSetMixin
|
|
from rest_framework.decorators import action
|
|
from rest_framework.renderers import BrowsableAPIRenderer
|
|
from rest_framework.renderers import JSONRenderer
|
|
from rest_framework_yaml.renderers import YAMLRenderer
|
|
from rest_framework_xml.renderers import XMLRenderer
|
|
from settings.puckomissions import IsAdminOrReadOnly
|
|
from settings.puckignation import MediumPagination
|
|
|
|
class PuckoView(GenericViewSet, ViewSetMixin):
|
|
authentication_classes = (TokenAuthentication,)
|
|
renderer_classes = (BrowsableAPIRenderer, JSONRenderer, YAMLRenderer, XMLRenderer)
|
|
|
|
class PuckoPagesView(PuckoView):
|
|
pagination_class = MediumPagination
|
|
|
|
def get_queryset(self, request=None):
|
|
return self.model_class.objects.all()
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
queryset = self.filter_queryset(self.get_queryset(request=request))
|
|
|
|
page = self.paginate_queryset(queryset)
|
|
if page is not None:
|
|
serializer = self.get_serializer(page, many=True)
|
|
return self.get_paginated_response(serializer.data)
|
|
|
|
serializer = self.get_serializer(queryset, many=True)
|
|
return Response(serializer.data)
|
|
|
|
def get_paginated_response(self, data, status=200):
|
|
"""
|
|
Return a paginated style `Response` object for the given output data.
|
|
"""
|
|
assert self.paginator is not None
|
|
return self.paginator.get_paginated_response(data, status=200)
|
|
|
|
def get_paginated_response_schema(self, *args, **kwargs):
|
|
assert self.paginator is not None
|
|
return self.paginator.get_paginated_response_schema(*args, **kwargs)
|
|
|
|
class PuckoPaginatedView(PuckoPagesView):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(PuckoPaginatedView).__init__(*args, **kwargs)
|
|
|
|
@action(detail=False)
|
|
def fetch_all(self, request):
|
|
query = self.paginator.paginate_queryset(self.get_queryset(), request)
|
|
serializer = self.serializer_class(query, many=True)
|
|
return self.get_paginated_response(serializer.data, status=200)
|
|
|
|
class PuckoSearchView(PuckoPagesView):
|
|
|
|
@action(detail=False)
|
|
def list(self, request):
|
|
serializer = self.serializer_class(data=request.data, many=False)
|
|
data = serializer.initial_data
|
|
if serializer.is_valid():
|
|
data = self.paginator.paginate_queryset(self.get_object(data), request)
|
|
ret = self.serializer_class(data, many=True)
|
|
if len(ret.data) < 1:
|
|
return Response({"message": "Could not find anything"}, status="404")
|
|
return self.get_paginated_response(ret.data, status=200)
|
|
return Response({"message": "not a valid search."}, status=400)
|
|
|
|
class PuckoAddView(PuckoView):
|
|
|
|
@action(detail=True)
|
|
def create(self, request):
|
|
serializer = self.serializer_class(data=request.data)
|
|
if serializer.is_valid():
|
|
serializer.save()
|
|
return Response(serializer.data, status=201)
|
|
return Response(serializer.errors, status=400)
|
|
|
|
class PuckoAllAddView(PuckoPaginatedView, PuckoAddView):
|
|
pass
|
|
|
|
class PuckoSlugView(PuckoView):
|
|
permission_classes = (IsAdminOrReadOnly,)
|
|
|
|
def get_object(self, slug):
|
|
try:
|
|
return self.model_class.objects.get(slug=slug)
|
|
except:
|
|
return Response({"message": f"{self.model_class.__class__.__name__} could not be found."})
|
|
|
|
@action(detail=True)
|
|
def retrieve(self, request, slug):
|
|
obj = self.get_object(slug)
|
|
if isinstance(obj, Response):
|
|
return obj
|
|
serializer = self.serializer_class(obj)
|
|
return Response(serializer.data, status=200)
|
|
|
|
@action(detail=True)
|
|
def update(self, request, slug):
|
|
obj = self.get_object(slug)
|
|
if isinstance(obj, Response):
|
|
return obj
|
|
serializer = self.serializer_class(obj, data=request.data)
|
|
if serializer.is_valid():
|
|
serializer.save()
|
|
return Response(serializer.data, status=201)
|
|
return Response(serializer.errors, status=400)
|
|
|
|
@action(detail=True)
|
|
def update_partial(self, request, slug):
|
|
obj = self.get_object(slug)
|
|
if isinstance(obj, Response):
|
|
return obj
|
|
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)
|
|
|
|
@action(detail=True)
|
|
def delete(self, request, slug):
|
|
obj = self.get_object(slug)
|
|
if isinstance(obj, Response):
|
|
return obj
|
|
if obj is None:
|
|
return Response({"message", "could not delete, what i could not find."})
|
|
obj.delete()
|
|
return Response({"message": f"{obj.__class__.__name__} deleted."}, status=204)
|