baseapp-pages: initial package

Author: nossila

.github/workflows/github-actions.yml

@@ -55,4 +55,8 @@ jobs:
   baseapp-follows:
     uses: ./.github/workflows/project-workflow.yml
     with:
-      project: baseapp-follows
+      project: baseapp-follows
+  baseapp-pages:
+    uses: ./.github/workflows/project-workflow.yml
+    with:
+      project: baseapp-pages

.github/workflows/publish-actions.yml

@@ -65,4 +65,9 @@ jobs:
     with:
       project: baseapp-follows
     secrets: inherit
+  baseapp-pages:
+    uses: ./.github/workflows/publish-workflow.yml
+    with:
+      project: baseapp-pages
+    secrets: inherit
 

README.md

@@ -52,6 +52,10 @@ Functionality for url shortening
 
 Reusable app to enable any model follow/unfollow any model.
 
+## [baseapp-pages](baseapp-pages)
+
+Reusable app to handle pages, URL's paths and metadata. It provides useful models and GraphQL Interfaces.
+
 ## How to develop
 
 Each module of baseapp-backend has a demo project in `testproject/` directory, which can be run as a standalone Django app to test. Then in baseapp-backend directory:

baseapp-core/baseapp_core/tests/settings.py

@@ -58,6 +58,7 @@
 MIDDLEWARE = [
     "django.middleware.security.SecurityMiddleware",
     "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.locale.LocaleMiddleware",
     "django.middleware.common.CommonMiddleware",
     "django.middleware.csrf.CsrfViewMiddleware",
     "django.contrib.auth.middleware.AuthenticationMiddleware",

baseapp-notifications/pyproject.toml

@@ -7,4 +7,4 @@ line-length = 100
 target_version = ['py38']
 
 [tool.isort]
-profile = "black"
+profile = "black"

baseapp-pages/README.md

@@ -0,0 +1,166 @@
+# BaseApp Pages
+
+Reusable app to handle pages, URL's paths and metadata. It provides useful models and GraphQL Interfaces.
+
+## Whats missing
+- [ ] Allow for custom settings.LANGUAGES per project
+- [ ] Make create migration work with TranslatedField
+
+Currenly if you have a different set of languages in your projects it will create a new migration changing the fields. So if you have a migration check test it will fail because the `settings.LANGUAGES are different.
+
+## How to install:
+
+Add dependencies to your `requirements/base.txt` file:
+
+```
+baseapp-pages
+```
+
+And run provision or manually `pip install -r requirements/base.ext`
+
+If you want to develop, [install using this other guide](#how-to-develop).
+
+## How to use
+
+Add `baseapp_pages` and `django_quill` to your project's `INSTALLED_APPS` and run `./manage.py migrate` as any other django model:
+
+```python
+INSTALLED_APPS = [
+    # ...
+    'baseapp_pages',
+    'django_quill',
+    # ...
+]
+```
+
+Add `django.middleware.locale.LocaleMiddleware` to the `MIDDLEWARE` list in your django settings file. [Check django's documentation for more information](https://docs.djangoproject.com/en/5.0/topics/i18n/translation/#how-django-discovers-language-preference).
+
+Add `baseapp_pages.permissions.PagesPermissionsBackend` to the `AUTHENTICATION_BACKENDS` list in your django settings file.
+
+Expose `PagesMutations` and `PagesQuery` in your GraphQL/graphene endpoint, like:
+
+```python
+from baseapp_pages.graphql.mutations import PagesMutations
+from baseapp_pages.graphql.queries import PagesQuery
+
+class Query(graphene.ObjectType, PagesQuery):
+    pass
+
+class Mutation(graphene.ObjectType, PagesMutations):
+    pass
+
+schema = graphene.Schema(query=Query, mutation=Mutation)
+```
+
+This will expose `urlPath` and `page` query.
+
+### `urlPath` query:
+
+Example:
+
+```graphql
+{
+    urlPath(path: '/about') {
+        path
+        language
+        target {
+            metadata {
+                metaTitle
+            }
+
+            ... on Page {
+                title
+            }
+        }
+    }
+}
+```
+
+### PageInterface
+
+`PageInterface` is a GraphQL interface that can be used to query for pages. It has the following fields:
+
+- `urlPath` return the active `URLPath`
+- `urlPaths` return all `URLPath` for the object, including inactive ones and in other languages
+- `metadata` return the `Metadata` for the object
+
+ObjectTypes that implements `PageInterface` is required to implement a resolve for `metadata` like this:
+
+```python
+from django.utils.translation import get_language
+from baseapp_core.graphql import DjangoObjectType
+from baseapp_pages.graphql import PageInterface, MetadataObjectType
+
+
+class MyModelObjectType(DjangoObjectType):
+    class Meta:
+        model = MyModel
+        interfaces = (relay.Node, PageInterface)
+
+    @classmethod
+    def resolve_metadata(cls, instance, info, **kwargs):
+        return MetadataObjectType(
+            meta_title=instance.title,
+            meta_description=instance.body[:160],
+            meta_og_image=instance.image.url,
+            meta_robots='noindex,nofollow'
+        )
+```
+
+If you want to support `Metadata` being manually set or overriden in the admin you can use the following code:
+
+```python
+class MyModelObjectType(DjangoObjectType):
+    # ...
+
+    @classmethod
+    def resolve_metadata(cls, instance, info, **kwargs):
+        target_content_type = ContentType.objects.get_for_model(instance)
+        metadata = MetadataObjectType._model.objects.filter(
+            target_content_type=target_content_type,
+            target_object_id=self.id,
+            language=get_language(),
+        ).first()
+        if not metadata:
+            return MetadataObjectType(
+                meta_title=instance.title,
+                # ...
+            )
+        return metadata
+```
+
+<!-- ## How to to customize the Page model
+
+In some cases you may need to extend Page model, and we can do it following the next steps:
+
+Start by creating a barebones django app:
+
+```
+mkdir my_project/pages
+touch my_project/pages/__init__.py
+touch my_project/pages/models.py
+```
+
+Your `models.py` will look something like this:
+
+```python
+from django.db import models
+
+from baseapp_pages.models import AbstractPage
+
+
+class Page(AbstractPage):
+    custom_field = models.CharField(null=True)
+```
+
+Now make your to add your new app to your `INSTALLED_APPS` and run `makemigrations` and `migrate` like any normal django app.
+
+Now in your `settings/base.py` make sure to tell baseapp-pages what is your custom model for Page:
+
+```python
+BASEAPP_PAGES_PAGE_MODEL = 'pages.Page'
+``` -->
+
+## How to develop
+
+General development instructions can be found in [main README](..#how-to-develop).

baseapp-pages/baseapp_pages/__init__.py

@@ -0,0 +1,44 @@
+import swapper
+from django.contrib import admin
+from django.contrib.contenttypes.admin import GenericStackedInline, GenericTabularInline
+from translated_fields import TranslatedFieldAdmin
+
+from baseapp_pages.models import Metadata, URLPath
+
+Page = swapper.load_model("baseapp_pages", "Page")
+
+
+class URLPathAdminInline(GenericTabularInline):
+    model = URLPath
+    extra = 0
+    ct_field = "target_content_type"
+    ct_fk_field = "target_object_id"
+
+
+@admin.register(URLPath)
+class URLPathAdmin(admin.ModelAdmin):
+    search_fields = ("path",)
+    list_display = ("id", "path", "language", "is_active", "target", "created")
+    list_filter = ("target_content_type", "language", "is_active")
+
+
+class MetadataAdminInline(GenericStackedInline):
+    model = Metadata
+    extra = 0
+    ct_field = "target_content_type"
+    ct_fk_field = "target_object_id"
+
+
+@admin.register(Page)
+class PageAdmin(TranslatedFieldAdmin, admin.ModelAdmin):
+    search_fields = ("title", "body")
+    raw_id_fields = ("user",)
+    list_display = ("id", "title", "created", "modified")
+    inlines = [URLPathAdminInline, MetadataAdminInline]
+
+
+@admin.register(Metadata)
+class MetadataAdmin(admin.ModelAdmin):
+    search_fields = ("meta_title", "meta_description")
+    list_display = ("target", "meta_title", "language", "created", "modified")
+    list_filter = ("target_content_type", "language")

baseapp-pages/baseapp_pages/admin.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class BaseAppPagesConfig(AppConfig):
+    name = "baseapp_pages"
+    verbose_name = "BaseApp Pages"
+    default_auto_field = "django.db.models.AutoField"

baseapp-pages/baseapp_pages/apps.py

@@ -0,0 +1,8 @@
+from .mutations import PageCreate, PageEdit  # noqa
+from .object_types import (  # noqa
+    MetadataObjectType,
+    PageInterface,
+    PageObjectType,
+    URLPathNode,
+)
+from .queries import PagesQueries  # noqa

baseapp-pages/baseapp_pages/graphql/__init__.py

@@ -0,0 +1,118 @@
+import graphene
+import swapper
+from baseapp_core.graphql import (
+    SerializerMutation,
+    get_pk_from_relay_id,
+    login_required,
+)
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
+from django.utils.translation import get_language
+from django.utils.translation import gettext_lazy as _
+from rest_framework import serializers
+
+from ..models import URLPath
+from .object_types import PageObjectType
+
+Page = swapper.load_model("baseapp_pages", "Page")
+
+
+class PageSerializer(serializers.ModelSerializer):
+    user = serializers.HiddenField(default=serializers.CurrentUserDefault())
+    url_path = serializers.CharField(required=False, allow_blank=True)
+    title = serializers.CharField(required=False, allow_blank=True)
+    body = serializers.CharField(required=False, allow_blank=True)
+
+    class Meta:
+        model = Page
+        fields = ("user", "title", "body", "url_path")
+
+    def validate_url_path(self, value):
+        language = get_language()
+        queryset = URLPath.objects.filter(
+            Q(language=language) | Q(language__isnull=True), path=value
+        )
+        if self.instance:
+            queryset = queryset.exclude(
+                target_content_type=ContentType.objects.get_for_model(self.instance),
+                target_object_id=self.instance.pk,
+            )
+
+        if queryset.exists():
+            raise serializers.ValidationError(_("URL Path already being used"))
+
+        return value
+
+    def save(self, **kwargs):
+        url_path = self.validated_data.pop("url_path", None)
+        instance = super().save(**kwargs)
+        language = get_language()
+        if url_path:
+            URLPath.objects.create(
+                target=instance, path=url_path, language=language, is_active=True
+            )
+        return instance
+
+
+class PageCreate(SerializerMutation):
+    page = graphene.Field(PageObjectType._meta.connection.Edge)
+
+    class Meta:
+        serializer_class = PageSerializer
+
+    @classmethod
+    @login_required
+    def mutate_and_get_payload(cls, root, info, **input):
+        if not info.context.user.has_perm("baseapp_pages.add_page"):
+            raise PermissionError(_("You don't have permission to create a page"))
+
+        return super().mutate_and_get_payload(root, info, **input)
+
+    @classmethod
+    def perform_mutate(cls, serializer, info):
+        obj = serializer.save()
+        return cls(
+            errors=None,
+            page=PageObjectType._meta.connection.Edge(node=obj),
+        )
+
+
+class PageEdit(SerializerMutation):
+    page = graphene.Field(PageObjectType)
+
+    class Meta:
+        serializer_class = PageSerializer
+
+    class Input:
+        id = graphene.ID(required=True)
+
+    @classmethod
+    def get_serializer_kwargs(cls, root, info, **input):
+        pk = get_pk_from_relay_id(input.get("id"))
+        instance = Page.objects.get(pk=pk)
+        if not info.context.user.has_perm("baseapp_pages.change_page", instance):
+            raise PermissionError(_("You don't have permission to edit this page"))
+        return {
+            "instance": instance,
+            "data": input,
+            "partial": True,
+            "context": {"request": info.context},
+        }
+
+    @classmethod
+    def perform_mutate(cls, serializer, info):
+        obj = serializer.save()
+        return cls(
+            errors=None,
+            page=obj,
+        )
+
+    @classmethod
+    @login_required
+    def mutate_and_get_payload(cls, root, info, **input):
+        return super().mutate_and_get_payload(root, info, **input)
+
+
+class PagesMutations(object):
+    page_create = PageCreate.Field()
+    page_edit = PageEdit.Field()