Add GenericApiView

Author: hishnash

channels_api/generics.py

@@ -0,0 +1,151 @@
+from typing import Dict, Type, Optional
+
+from asgiref.sync import async_to_sync
+from channels.db import database_sync_to_async
+from django.db.models import QuerySet, Model
+from rest_framework.generics import get_object_or_404, GenericAPIView
+from rest_framework.serializers import Serializer
+
+from channels_api.views import AsyncWebsocketAPIView
+
+GenericAPIView
+
+class GenericAsyncWebsocketAPIView(AsyncWebsocketAPIView):
+    """
+    Base class for all other generic views.
+    """
+
+    # You'll need to either set these attributes,
+    # or override `get_queryset()`/`get_serializer_class()`.
+    # If you are overriding a view method, it is important that you call
+    # `get_queryset()` instead of accessing the `queryset` property directly,
+    # as `queryset` will get evaluated only once, and those results are cached
+    # for all subsequent requests.
+
+    queryset = None  # type: QuerySet
+    serializer_class = None  # type: Type[Serializer]
+
+    # If you want to use object lookups other than pk, set 'lookup_field'.
+    # For more complex lookup requirements override `get_object()`.
+    lookup_field = 'pk'  # type: str
+    lookup_url_kwarg = None  # type: Optional[str]
+
+    # TODO filter_backends
+
+    # TODO pagination_class
+
+    async def get_queryset(self, action: str, **kwargs) -> QuerySet:
+        """
+        Get the list of items for this view.
+        This must be an iterable, and may be a queryset.
+        Defaults to using `self.queryset`.
+
+        This method should always be used rather than accessing `self.queryset`
+        directly, as `self.queryset` gets evaluated only once, and those results
+        are cached for all subsequent requests.
+
+        You may want to override this if you need to provide different
+        querysets depending on the incoming request.
+
+        (Eg. return a list of items that is specific to the user)
+        """
+        assert self.queryset is not None, (
+            "'%s' should either include a `queryset` attribute, "
+            "or override the `get_queryset()` method."
+            % self.__class__.__name__
+        )
+
+        queryset = self.queryset
+        if isinstance(queryset, QuerySet):
+            # Ensure queryset is re-evaluated on each request.
+            queryset = queryset.all()
+        return queryset
+
+    async def get_object(self, action: str, **kwargs) ->Model:
+        """
+        Returns the object the view is displaying.
+
+        You may want to override this if you need to provide non-standard
+        queryset lookups.  Eg if objects are referenced using multiple
+        keyword arguments in the url conf.
+        """
+        queryset = await self.filter_queryset(
+            queryset=await self.get_queryset(action=action, **kwargs),
+            action=action,
+            **kwargs
+        )
+
+        # Perform the lookup filtering.
+        lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field
+
+        assert lookup_url_kwarg in kwargs, (
+                'Expected view %s to be called with a URL keyword argument '
+                'named "%s". Fix your URL conf, or set the `.lookup_field` '
+                'attribute on the view correctly.' %
+                (self.__class__.__name__, lookup_url_kwarg)
+        )
+
+        filter_kwargs = {self.lookup_field: kwargs[lookup_url_kwarg]}
+
+        obj = await database_sync_to_async(get_object_or_404)(queryset, **filter_kwargs)
+        # TODO check_object_permissions
+
+        return obj
+
+    async def get_serializer(
+            self, action: str,
+            action_kwargs: Dict=None,
+            *args, **kwargs):
+        """
+        Return the serializer instance that should be used for validating and
+        deserializing input, and for serializing output.
+        """
+        serializer_class = await self.get_serializer_class(
+            action=action, **action_kwargs
+        )
+
+        kwargs['context'] = await self.get_serializer_context(
+            action=action, **action_kwargs
+        )
+
+        return serializer_class(*args, **kwargs)
+
+    async def get_serializer_class(self, action: str, **kwargs) -> Type[Serializer]:
+        """
+        Return the class to use for the serializer.
+        Defaults to using `self.serializer_class`.
+
+        You may want to override this if you need to provide different
+        serializations depending on the incoming request.
+
+        (Eg. admins get full serialization, others get basic serialization)
+        """
+        assert self.serializer_class is not None, (
+            "'%s' should either include a `serializer_class` attribute, "
+            "or override the `get_serializer_class()` method."
+            % self.__class__.__name__
+        )
+
+        return self.serializer_class
+
+    async def get_serializer_context(self, action: str, **kwargs):
+        """
+        Extra context provided to the serializer class.
+        """
+        return {
+            'scope': self.scope,
+            'consumer': self
+        }
+
+    async def filter_queryset(self, queryset: QuerySet, action: str, **kwargs):
+        """
+        Given a queryset, filter it with whichever filter backend is in use.
+
+        You are unlikely to want to override this method, although you may need
+        to call it either from a list view, or from a custom `get_object`
+        method if you want to apply the configured filtering backend to the
+        default queryset.
+        """
+        # TODO filter_backends
+
+        return queryset

channels_api/views.py

@@ -12,7 +12,7 @@
     WebsocketConsumer
 from django.conf.urls import url
 from django.http import HttpRequest, HttpResponse
-from django.http.response import HttpResponseBase
+from django.http.response import HttpResponseBase, Http404
 from django.template.response import SimpleTemplateResponse
 from django.urls import Resolver404, reverse, resolve
 
@@ -92,6 +92,13 @@ async def handle_exception(self, exc: Exception, action: str, request_id):
                 status=exc.status_code,
                 request_id=request_id
             )
+        elif exc == Http404 or isinstance(exc, Http404):
+            await self.reply(
+                action=action,
+                errors=self._format_errors('Not found'),
+                status=404,
+                request_id=request_id
+            )
         else:
             raise exc
 
@@ -266,7 +273,7 @@ def view_as_consumer(
         wrapped_view: typing.Callable[[HttpRequest], HttpResponse],
         mapped_actions: typing.Optional[
             typing.Dict[str, str]
-        ] =None) -> Type[AsyncConsumer]:
+        ]=None) -> Type[AsyncConsumer]:
     """
     Wrap a django View so that it will be triggered by actions over this json
      websocket consumer.

tests/test_generic_view.py

@@ -0,0 +1,97 @@
+import pytest
+from channels.testing import WebsocketCommunicator
+from django.contrib.auth import get_user_model
+from rest_framework import serializers
+
+from channels_api.decorators import action
+from channels_api.generics import GenericAsyncWebsocketAPIView
+
+
+@pytest.mark.django_db(transaction=True)
+@pytest.mark.asyncio
+async def test_generic_view():
+
+    results = {}
+
+    class UserSerializer(serializers.ModelSerializer):
+        class Meta:
+            model = get_user_model()
+            fields = ('id', 'username', 'email',)
+
+    class AView(GenericAsyncWebsocketAPIView):
+        queryset = get_user_model().objects.all()
+        serializer_class = UserSerializer
+
+        @action()
+        async def test_async_action(self, reply, pk=None):
+            user = await self.get_object(action='test_async_action', pk=pk)
+
+            s = await self.get_serializer(
+                action='test_async_action',
+                action_kwargs={'pk': pk},
+                instance=user
+            )
+            await reply(data=s.data, status=200)
+
+        @action()
+        def test_sync_action(self, pk=None):
+            results['test_sync_action'] = pk
+            return {'pk': pk, 'sync': True}, 200
+
+    # Test a normal connection
+    communicator = WebsocketCommunicator(AView, "/testws/")
+    connected, _ = await communicator.connect()
+    assert connected
+
+    await communicator.send_json_to(
+        {
+            "action": "test_async_action",
+            "pk": 2,
+            "request_id": 1
+        }
+    )
+
+    response = await communicator.receive_json_from()
+
+    assert response == {
+            "action": "test_async_action",
+            "errors": ["Not found"],
+            "response_status": 404,
+            "request_id": 1,
+            "data": None,
+        }
+
+    user = get_user_model().objects.create(
+        username='test1', email='[email protected]'
+    )
+
+    pk = user.id
+
+    assert get_user_model().objects.filter(pk=pk).exists()
+
+    await communicator.disconnect()
+
+    communicator = WebsocketCommunicator(AView, "/testws/")
+    connected, _ = await communicator.connect()
+
+    assert connected
+
+    await communicator.send_json_to(
+        {
+            "action": "test_async_action",
+            "pk": pk,
+            "request_id": 2
+        }
+    )
+
+    response = await communicator.receive_json_from()
+
+    assert response == {
+        "action": "test_async_action",
+        "errors": [],
+        "response_status": 200,
+        "request_id": 2,
+        "data": {'email': '[email protected]', 'id': 1, 'username': 'test1'}
+    }
+
+    await communicator.disconnect()

tests/test_views.py

@@ -4,7 +4,7 @@
 from channels_api.decorators import action
 from channels_api.views import AsyncWebsocketAPIView
 
-
+@pytest.mark.django_db(transaction=True)
 @pytest.mark.asyncio
 async def test_decorator():