implemented an asyncified flatpages app

Author: amirreza8002

django_async_extensions/acontrib/flatpages/__init__.py

@@ -0,0 +1,23 @@
+from django.contrib import admin
+from django.contrib.flatpages.models import FlatPage
+from django.utils.translation import gettext_lazy as _
+
+from django_async_extensions.acontrib.flatpages.forms import AsyncFlatPageForm
+
+
+@admin.register(FlatPage)
+class FlatPageAdmin(admin.ModelAdmin):
+    form = AsyncFlatPageForm
+    fieldsets = (
+        (None, {"fields": ("url", "title", "content", "sites")}),
+        (
+            _("Advanced options"),
+            {
+                "classes": ("collapse",),
+                "fields": ("registration_required", "template_name"),
+            },
+        ),
+    )
+    list_display = ("url", "title")
+    list_filter = ("sites", "registration_required")
+    search_fields = ("url", "title")

django_async_extensions/acontrib/flatpages/admin.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class FlatPagesConfig(AppConfig):
+    default_auto_field = "django.db.models.AutoField"
+    name = "django.contrib.flatpages"
+    verbose_name = _("Flat Pages")

django_async_extensions/acontrib/flatpages/apps.py

@@ -0,0 +1,9 @@
+from django.contrib.flatpages.forms import FlatpageForm
+
+from asgiref.sync import sync_to_async
+
+
+class AsyncFlatPageForm(FlatpageForm):
+    async def asave(self, commit=True):
+        return await sync_to_async(self.save)(commit=commit)
+

django_async_extensions/acontrib/flatpages/forms.py

@@ -0,0 +1,39 @@
+from django.conf import settings
+from django.http import Http404
+from django.utils.deprecation import MiddlewareMixin
+
+from asgiref.sync import sync_to_async
+
+from django_async_extensions.acontrib.flatpages.views import flatpage
+
+
+class AsyncFlatpageFallbackMiddleware(MiddlewareMixin):
+    async def process_response(self, request, response):
+        if response.status_code != 404:
+            return response  # No need to check for a flatpage for non-404 responses.
+        try:
+            return await flatpage(request, request.path_info)
+        # Return the original response if any errors happened. Because this
+        # is a middleware, we can't assume the errors will be caught elsewhere.
+        except Http404:
+            return response
+        except Exception:
+            if settings.DEBUG:
+                raise
+            return response
+
+    async def __acall__(self, request):
+        """
+        Async version of __call__ that is swapped in when an async request
+        is running.
+        """
+        response = None
+        if hasattr(self, "process_request"):
+            response = await sync_to_async(
+                self.process_request,
+                thread_sensitive=True,
+            )(request)
+        response = response or await self.get_response(request)
+        if hasattr(self, "process_response"):
+            response = await self.process_response(request, response)
+        return response

django_async_extensions/acontrib/flatpages/middleware.py

@@ -0,0 +1,7 @@
+from django.urls import path
+
+from django_async_extensions.acontrib.flatpages import views
+
+urlpatterns = [
+    path("<path:url>", views.flatpage, name="django.contrib.flatpages.views.flatpage"),
+]

django_async_extensions/acontrib/flatpages/urls.py

@@ -0,0 +1,71 @@
+from django.conf import settings
+from django.contrib.flatpages.models import FlatPage
+from django.contrib.sites.shortcuts import get_current_site
+from django.http import Http404, HttpResponse, HttpResponsePermanentRedirect
+from django.shortcuts import aget_object_or_404
+from django.template import loader
+from django.utils.safestring import mark_safe
+from django.views.decorators.csrf import csrf_protect
+
+DEFAULT_TEMPLATE = "flatpages/default.html"
+
+# This view is called from FlatpageFallbackMiddleware.process_response
+# when a 404 is raised, which often means CsrfViewMiddleware.process_view
+# has not been called even if CsrfViewMiddleware is installed. So we need
+# to use @csrf_protect, in case the template needs {% csrf_token %}.
+# However, we can't just wrap this view; if no matching flatpage exists,
+# or a redirect is required for authentication, the 404 needs to be returned
+# without any CSRF checks. Therefore, we only
+# CSRF protect the internal implementation.
+
+
+async def flatpage(request, url):
+    """
+    Public interface to the flat page view.
+
+    Models: `flatpages.flatpages`
+    Templates: Uses the template defined by the ``template_name`` field,
+        or :template:`flatpages/default.html` if template_name is not defined.
+    Context:
+        flatpage
+            `flatpages.flatpages` object
+    """
+    if not url.startswith("/"):
+        url = "/" + url
+    site_id = get_current_site(request).id
+    try:
+        f = await aget_object_or_404(FlatPage, url=url, sites=site_id)
+    except Http404:
+        if not url.endswith("/") and settings.APPEND_SLASH:
+            url += "/"
+            f = await aget_object_or_404(FlatPage, url=url, sites=site_id)
+            return HttpResponsePermanentRedirect("%s/" % request.path)
+        else:
+            raise
+    return await render_flatpage(request, f)
+
+
+@csrf_protect
+async def render_flatpage(request, f):
+    """
+    Internal interface to the flat page view.
+    """
+    # If registration is required for accessing this page, and the user isn't
+    # logged in, redirect to the login page.
+    user = await request.auser()
+    if f.registration_required and not user.is_authenticated:
+        from django.contrib.auth.views import redirect_to_login
+
+        return redirect_to_login(request.path)
+    if f.template_name:
+        template = loader.select_template((f.template_name, DEFAULT_TEMPLATE))
+    else:
+        template = loader.get_template(DEFAULT_TEMPLATE)
+
+    # To avoid having to always use the "|safe" filter in flatpage templates,
+    # mark the title and content as already safe (since they are raw HTML
+    # content in the first place).
+    f.title = mark_safe(f.title)
+    f.content = mark_safe(f.content)
+
+    return HttpResponse(template.render({"flatpage": f}, request))