django-simple-page 1.0.0__tar.gz

django_simple_page-1.0.0/LICENCE

@@ -0,0 +1,27 @@
+Copyright (c) 2020, Thomas Leichtfuß.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of the author nor the names of contributors
+       may be used to endorse or promote products derived from this software
+       without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

django_simple_page-1.0.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: django-simple-page
+Version: 1.0.0
+Author-email: Thomas Leichtfuß <thomas.leichtfuss@posteo.de>
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/thomst/django-simple-page
+Project-URL: Repository, https://github.com/thomst/django-simple-page
+Project-URL: Documentation, https://github.com/thomst/django-simple-page#readme
+Keywords: django,django-admin,cms,website
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: Django>=3.2
+Requires-Dist: django-mptt
+Requires-Dist: django-model-utils
+Requires-Dist: django-reorder_items_widget
+Provides-Extra: test
+Requires-Dist: Pillow; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Dynamic: license-file
+
+# Welcome to django-simple-page
+
+[![Tests](https://github.com/thomst/django-simple-page/actions/workflows/tests.yml/badge.svg)](https://github.com/thomst/django-simple-page/actions/workflows/tests.yml)
+[![Coverage Status](https://coveralls.io/repos/github/thomst/django-simple-page/badge.svg?branch=main)](https://coveralls.io/github/thomst/django-simple-page?branch=main)
+[<img src="https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange">](https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange)
+
+Django-simple-page is a cms buildkit for your website. The strength of this
+project is its simplicity - using comprehensible yet powerful concepts. You get
+the basic stuff, but retain all your freedom.
+
+## Links
+
+- [github](https://github.com/django-simple-page/)
+- [docs](https://thomst.github.io/django-simple-page/)
+- [pypi](https://pypi.org/project/django-simple-page/)
+
+
+## Features
+
+- **Tree structured Pages**: By django-mptt.
+- **Pages, regions and sections**: Assigning sections to regions on pages.
+- **Custom rendering logic**: Each page or section can have its own renderer.
+- **Simple yet powerful concept**: Everything can be customized by subclassing.
+- **Admin backend integration**: Easy to use. Order elements via drag and drop.
+
+
+## Description
+
+### Pages, regions and sections
+
+You got a reliable database layout of pages and sections. Sections are
+associated with regions on pages. Everything else is up to you. Sections could
+be anything you want, from a simple content type like an article with title and
+text body to a full featured gallery. You build what you need just by
+subclassing the page and section model.
+
+### Renderer
+
+While there are default renderers for pages and sections which are probably
+suitable for most use cases, you are free to completely adapt or overwrite them.
+Each page or section can have its own renderer providing a specific rendering
+logic. And each renderer can have its own Media class defining javascript or css
+files. Those media assets are merged by the page renderer and be available as
+`media` template variable.
+
+### Admin integration
+
+At least we provide a handy admin backend integration. Rearrange your pages by
+drag and drop. Add sections to your page regions with inline formsets and
+reorder them by just dragging them to their new position. It's simple and
+sufficient.
+
+### Summing-up
+
+As you can see, everything is done by subclassing. While django-simple-page
+giving you the basics to build your website, it is not taking any freedom from
+you. You define your pages with regions, your sections as content, your
+rendering logic with their media classes and put everything together like
+building blocks.

django_simple_page-1.0.0/README.md

@@ -0,0 +1,59 @@
+# Welcome to django-simple-page
+
+[![Tests](https://github.com/thomst/django-simple-page/actions/workflows/tests.yml/badge.svg)](https://github.com/thomst/django-simple-page/actions/workflows/tests.yml)
+[![Coverage Status](https://coveralls.io/repos/github/thomst/django-simple-page/badge.svg?branch=main)](https://coveralls.io/github/thomst/django-simple-page?branch=main)
+[<img src="https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange">](https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange)
+
+Django-simple-page is a cms buildkit for your website. The strength of this
+project is its simplicity - using comprehensible yet powerful concepts. You get
+the basic stuff, but retain all your freedom.
+
+## Links
+
+- [github](https://github.com/django-simple-page/)
+- [docs](https://thomst.github.io/django-simple-page/)
+- [pypi](https://pypi.org/project/django-simple-page/)
+
+
+## Features
+
+- **Tree structured Pages**: By django-mptt.
+- **Pages, regions and sections**: Assigning sections to regions on pages.
+- **Custom rendering logic**: Each page or section can have its own renderer.
+- **Simple yet powerful concept**: Everything can be customized by subclassing.
+- **Admin backend integration**: Easy to use. Order elements via drag and drop.
+
+
+## Description
+
+### Pages, regions and sections
+
+You got a reliable database layout of pages and sections. Sections are
+associated with regions on pages. Everything else is up to you. Sections could
+be anything you want, from a simple content type like an article with title and
+text body to a full featured gallery. You build what you need just by
+subclassing the page and section model.
+
+### Renderer
+
+While there are default renderers for pages and sections which are probably
+suitable for most use cases, you are free to completely adapt or overwrite them.
+Each page or section can have its own renderer providing a specific rendering
+logic. And each renderer can have its own Media class defining javascript or css
+files. Those media assets are merged by the page renderer and be available as
+`media` template variable.
+
+### Admin integration
+
+At least we provide a handy admin backend integration. Rearrange your pages by
+drag and drop. Add sections to your page regions with inline formsets and
+reorder them by just dragging them to their new position. It's simple and
+sufficient.
+
+### Summing-up
+
+As you can see, everything is done by subclassing. While django-simple-page
+giving you the basics to build your website, it is not taking any freedom from
+you. You define your pages with regions, your sections as content, your
+rendering logic with their media classes and put everything together like
+building blocks.

django_simple_page-1.0.0/django_simple_page.egg-info/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: django-simple-page
+Version: 1.0.0
+Author-email: Thomas Leichtfuß <thomas.leichtfuss@posteo.de>
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/thomst/django-simple-page
+Project-URL: Repository, https://github.com/thomst/django-simple-page
+Project-URL: Documentation, https://github.com/thomst/django-simple-page#readme
+Keywords: django,django-admin,cms,website
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 3.2
+Classifier: Framework :: Django :: 4.0
+Classifier: Framework :: Django :: 4.1
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.0
+Classifier: Framework :: Django :: 5.1
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: Django>=3.2
+Requires-Dist: django-mptt
+Requires-Dist: django-model-utils
+Requires-Dist: django-reorder_items_widget
+Provides-Extra: test
+Requires-Dist: Pillow; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Dynamic: license-file
+
+# Welcome to django-simple-page
+
+[![Tests](https://github.com/thomst/django-simple-page/actions/workflows/tests.yml/badge.svg)](https://github.com/thomst/django-simple-page/actions/workflows/tests.yml)
+[![Coverage Status](https://coveralls.io/repos/github/thomst/django-simple-page/badge.svg?branch=main)](https://coveralls.io/github/thomst/django-simple-page?branch=main)
+[<img src="https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange">](https://img.shields.io/badge/django-3.2%20%7C%204.0%20%7C%204.1%20%7C%204.2%20%7C%205.0%20%7C%205.1%20%7C%205.2%20%7C%206.0-orange)
+
+Django-simple-page is a cms buildkit for your website. The strength of this
+project is its simplicity - using comprehensible yet powerful concepts. You get
+the basic stuff, but retain all your freedom.
+
+## Links
+
+- [github](https://github.com/django-simple-page/)
+- [docs](https://thomst.github.io/django-simple-page/)
+- [pypi](https://pypi.org/project/django-simple-page/)
+
+
+## Features
+
+- **Tree structured Pages**: By django-mptt.
+- **Pages, regions and sections**: Assigning sections to regions on pages.
+- **Custom rendering logic**: Each page or section can have its own renderer.
+- **Simple yet powerful concept**: Everything can be customized by subclassing.
+- **Admin backend integration**: Easy to use. Order elements via drag and drop.
+
+
+## Description
+
+### Pages, regions and sections
+
+You got a reliable database layout of pages and sections. Sections are
+associated with regions on pages. Everything else is up to you. Sections could
+be anything you want, from a simple content type like an article with title and
+text body to a full featured gallery. You build what you need just by
+subclassing the page and section model.
+
+### Renderer
+
+While there are default renderers for pages and sections which are probably
+suitable for most use cases, you are free to completely adapt or overwrite them.
+Each page or section can have its own renderer providing a specific rendering
+logic. And each renderer can have its own Media class defining javascript or css
+files. Those media assets are merged by the page renderer and be available as
+`media` template variable.
+
+### Admin integration
+
+At least we provide a handy admin backend integration. Rearrange your pages by
+drag and drop. Add sections to your page regions with inline formsets and
+reorder them by just dragging them to their new position. It's simple and
+sufficient.
+
+### Summing-up
+
+As you can see, everything is done by subclassing. While django-simple-page
+giving you the basics to build your website, it is not taking any freedom from
+you. You define your pages with regions, your sections as content, your
+rendering logic with their media classes and put everything together like
+building blocks.

django_simple_page-1.0.0/django_simple_page.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENCE
+README.md
+pyproject.toml
+django_simple_page.egg-info/PKG-INFO
+django_simple_page.egg-info/SOURCES.txt
+django_simple_page.egg-info/dependency_links.txt
+django_simple_page.egg-info/requires.txt
+django_simple_page.egg-info/top_level.txt
+simple_page/__init__.py
+simple_page/__version__.py
+simple_page/admin.py
+simple_page/apps.py
+simple_page/forms.py
+simple_page/models.py
+simple_page/renderer.py
+simple_page/signals.py
+simple_page/views.py
+simple_page/templates/admin/simple_page/page/change_form.html
+simple_page/templates/simple_page/menu.html

django_simple_page-1.0.0/django_simple_page.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_simple_page-1.0.0/django_simple_page.egg-info/requires.txt

@@ -0,0 +1,8 @@
+Django>=3.2
+django-mptt
+django-model-utils
+django-reorder_items_widget
+
+[test]
+Pillow
+coverage

django_simple_page-1.0.0/django_simple_page.egg-info/top_level.txt

@@ -0,0 +1 @@
+simple_page

django_simple_page-1.0.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-simple-page"
+authors = [{name = "Thomas Leichtfuß", email = "thomas.leichtfuss@posteo.de"}]
+description = ""
+readme = "README.md"
+requires-python = ">=3.8"
+keywords = ["django", "django-admin", "cms", "website"]
+license = { text = "BSD-3-Clause"}
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: Django",
+    "Framework :: Django :: 3.2",
+    "Framework :: Django :: 4.0",
+    "Framework :: Django :: 4.1",
+    "Framework :: Django :: 4.2",
+    "Framework :: Django :: 5.0",
+    "Framework :: Django :: 5.1",
+    "Framework :: Django :: 5.2",
+    "Framework :: Django :: 6.0",
+    "Environment :: Web Environment",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+    "Topic :: Software Development",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+dependencies = [
+    "Django>=3.2",
+    "django-mptt",
+    "django-model-utils",
+    "django-reorder_items_widget",
+]
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://github.com/thomst/django-simple-page"
+Repository = "https://github.com/thomst/django-simple-page"
+Documentation = "https://github.com/thomst/django-simple-page#readme"
+
+[tool.setuptools]
+packages = ["simple_page"]
+include-package-data = false
+
+[tool.setuptools.package-data]
+simple_page = ["templates/**"]
+
+[tool.setuptools.dynamic]
+version = {attr = "simple_page.__version__.__version__"}
+
+[project.optional-dependencies]
+test = [
+    "Pillow",
+    "coverage",
+]

django_simple_page-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

django_simple_page-1.0.0/simple_page/__init__.py

@@ -0,0 +1,75 @@
+"""
+This is django-simple-page
+==========================
+
+Django-simple-page is a cms buildkit for your website. The strength of this
+project is its simplicity - using comprehensible yet powerful concepts. You get
+the basic stuff, but retain all your freedom.
+
+Features
+========
+
+- **Tree structured Pages**: By `django-mptt`_.
+- **Pages and sections**: Assigning sections to regions on pages.
+- **Renderer**: Each page or section can have its own renderer.
+- **Simple yet powerful concept**: Everything can be customized by subclassing.
+- **Admin backend integration**: Easy to use. Order elements via drag and drop.
+
+.. _django-mptt: https://django-mptt.readthedocs.io/en/latest/
+
+Basic Concept
+=============
+
+Pages and sections
+------------------
+
+You got a reliable database layout of :class:`pages <.models.Page>` and
+:class:`sections <.models.Section>` objects. Sections are associated with
+regions on pages. Everything else is up to you. Sections could be anything you
+want, from a simple content type like an article with title and text body to a
+full featured gallery. You build what you need just by subclassing the page and
+section model.
+
+Renderer
+--------
+
+While there are default :mod:`renderers <.renderer>` for pages and sections
+which are probably suitable for most use cases, you are free to completely adapt
+or overwrite them. Each page or section can have its own renderer providing a
+specific rendering logic. And each renderer can have its own Media class
+defining javascript or css files. Those media assets are merged by the page
+renderer and be available as `media` template variable.
+
+Summing-up
+----------
+
+As you can see, everything is done by subclassing. While django-simple-page
+giving you the basics to build your website, it is not taking any freedom from
+you. You define your pages with regions, your sections as content, your
+rendering logic with their media classes and put everything together like
+building blocks.
+
+
+Admin integration
+=================
+
+We provide a handy admin backend integration. Rearrange your pages by drag and
+drop. Add sections to your page regions with inline formsets and reorder them by
+just dragging them to their new position. It's simple and sufficient.
+
+
+Utils
+=====
+
+Menu template tag
+-----------------
+We provide an inclusion template tag to generate a tree based menu using nested
+lists. Still you are free to build your own menu logic or customize the default
+menu template to your needs. See :func:`~.templatetags.simple_page.menu` for
+more details.
+
+Page view
+---------
+A simple view function to render a page by its slug. Use it in your url
+configuration. See :func:`~.views.page_view` for more details.
+"""

django_simple_page-1.0.0/simple_page/__version__.py

@@ -0,0 +1,16 @@
+"""
+This project uses the Semantic Versioning scheme in conjunction with PEP 0440:
+    <http://semver.org/>
+    <https://www.python.org/dev/peps/pep-0440>
+
+Major versions introduce significant changes to the API, and backwards
+compatibility is not guaranteed. Minor versions are for new features and other
+backwards-compatible changes to the API. Patch versions are for bug fixes and
+internal code changes that do not affect the API. Development versions are
+incomplete states of a release .
+
+Version 0.x should be considered a development version with an unstable API,
+and backwards compatibility is not guaranteed for minor versions.
+"""
+
+__version__ = "1.0.0"

django_simple_page-1.0.0/simple_page/admin.py

@@ -0,0 +1,199 @@
+"""
+The admin integration for django-simple-page is realized by a customized
+:class:`page modeladmin <.PageAdmin>`. This modeladmin is registered for the
+page model and will be used for all proxy page models. It provides the following
+features:
+
+- Let pages be orderable by drag and drop in the admin changelist view.
+- Let the user choose the type of the page before rendering the page's add form.
+- Set the initial value of the hidden page_type field in the page add form.
+- Render an inline formset for each region of the page which allows to assign
+  sections to the region and rearrange them via drag and drop.
+
+For your own concrete page models you should use :class:`~.admin.BasePageAdmin`
+as a base class for your modeladmin. It will take care of rendering the inline
+formsets for regions and setting the appropriate value for the hidden page_type
+field.
+"""
+
+from django.contrib import admin
+from django.forms import HiddenInput
+from django.utils.functional import cached_property
+from django.utils.html import mark_safe
+from django.urls import reverse
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import gettext as _
+from mptt.admin import DraggableMPTTAdmin
+from .models import Page, PageSection
+from .forms import ReorderRelationForm
+
+
+class BaseRegionInline(admin.TabularInline):
+    """
+    Inline for the :class:`~.models.PageSection` model. Each region of a page
+    gets its own inline table with sections belonging to that region. We use
+    the django-reorder-items-widget_ to make the sections orderable via drag and
+    drop within their region.
+
+    .. _django-reorder-items-widget: https://github.com/thomst/django-reorder-items-widget
+    """
+    region_name = None
+    form = ReorderRelationForm
+    model = PageSection
+    extra = 1
+    fields = ("section", "index", "region")
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        return qs.filter(region=self.region_name)
+
+    class Media:
+        js = ["simple_page/formset_handlers.js"]
+
+
+class GetPageModelMixin:
+    """
+    A mixin to get the page model based on a page_type url query parameter or
+    the page_type field of the current page object.
+    """
+
+    @cached_property
+    def page_types(self):
+        """
+        Return content types of all page models.
+        """
+        exclude_apps = ["admin", "auth", "contenttypes", "sessions", "simple_page"]
+        cts = ContentType.objects.exclude(app_label__in=exclude_apps)
+        return [ct for ct in cts if ct.model_class() and issubclass(ct.model_class(), Page)]
+
+    def get_page_model(self, request, obj=None):
+        """
+        Return the page model based on the request and object.
+        """
+        if obj:
+            return obj.page_type.model_class()
+        elif 'page_type' in request.GET:
+            page_type_id = request.GET['page_type']
+            try:
+                page_type = [ct for ct in self.page_types if ct.id == int(page_type_id)][0]
+            except (IndexError, ValueError):
+                raise ValueError(f"Invalid page type id: {page_type_id}")
+            else:
+                return page_type.model_class()
+        else:
+            return self.model
+
+
+class RenderPageRegionsMixin(GetPageModelMixin):
+    """
+    Render a :class:`~.models.PageSection` inline formset for each region of the
+    page. Also make sure extra forms have the region's name as initial value for
+    the region form field.
+    """
+
+    def get_page_regions(self, request, obj):
+        return self.get_page_model(request, obj).get_regions()
+
+    def get_formset_kwargs(self, request, obj, inline, prefix):
+        kwargs = super().get_formset_kwargs(request, obj, inline, prefix)
+        if isinstance(inline, BaseRegionInline):
+             kwargs["initial"] = [
+                {"region": inline.region_name}
+                for i in range(inline.extra)
+            ]
+        return kwargs
+
+    def get_inlines(self, request, obj):
+        inlines = list(super().get_inlines(request, obj))
+        regions = self.get_page_regions(request, obj)
+        for region, title in regions:
+            class_name = f"{region.capitalize()}Inline"
+            attrs = dict(
+                region_name=region,
+                verbose_name=title,
+                verbose_name_plural=title,
+                )
+            inlines.append(type(class_name, (BaseRegionInline,), attrs))
+        return inlines
+
+
+class ChoosePageTypeMixin(GetPageModelMixin):
+    """
+    Let the user choose the type of the page she wants to add. Therefore render
+    a simple list of add-links which either set the page_type url-query
+    parameter for proxy page models or link to the modeladmin changeform
+    for concrete page models.
+    """
+
+    def render_change_form(self, request, context, add=False, change=False, form_url="", obj=None):
+        # Set the title of the change form based on the page type.
+        if add or change:
+            title = _("Add %s") if add else _("Change %s")
+        else:
+            title = _("View %s")
+        page_model = self.get_page_model(request, obj)
+        context["title"] = title % page_model._meta.verbose_name
+        return super().render_change_form(request, context, add, change, form_url, obj)
+
+    def add_view(self, request, form_url="", extra_context=None):
+        # Add page types to the context to render a list of add links for each
+        # page type. Using their content type id in the query string.
+        if "page_type" not in request.GET:
+            extra_context = extra_context or {}
+            extra_context["page_types"] = []
+            for ct in self.page_types:
+                name = ct.model_class()._meta.verbose_name
+                if ct.model_class()._meta.proxy:
+                    url = f"?page_type={ct.id}"
+                else:
+                    url = reverse(f"admin:{ct.app_label}_{ct.model}_add")
+                extra_context["page_types"].append((url, name))
+        return super().add_view(request, form_url, extra_context)
+
+
+class SetPageTypeMixin(GetPageModelMixin):
+    """
+    Set the initial value of the hidden page_type field in changeforms when
+    adding a new page.
+    """
+
+    def get_form(self, request, obj=None, **kwargs):
+        form = super().get_form(request, obj, **kwargs)
+        page_model = self.get_page_model(request, obj)
+        form.base_fields["page_type"].initial = ContentType.objects.get_for_model(page_model)
+        form.base_fields["page_type"].widget = HiddenInput()
+        return form
+
+
+@admin.register(Page)
+class PageAdmin(SetPageTypeMixin, ChoosePageTypeMixin, RenderPageRegionsMixin, DraggableMPTTAdmin):
+    """
+    The modeladmin for all proxy page models. This modeladmin is already
+    registered for the page model. It provides the following features:
+
+    - Let pages be orderable by drag and drop in the admin changelist view.
+    - Let the user choose the type of the page before rendering the page's add
+      form.
+    - Set the initial value of the hidden page_type field in the page add form.
+    - Render an inline formset for each region of the page.
+    """
+    list_display = ("tree_actions", "indented_title", "slug", "page_type", "view_page_link")
+    list_display_links=('indented_title',)
+    search_fields = ("title", "slug")
+    prepopulated_fields = {"slug": ("title",)}
+    list_filter = ("parent",)
+
+    def view_page_link(self, obj):
+        url = obj.get_absolute_url()
+        return mark_safe(f'<a href="{url}" target="_blank">View page</a>')
+    view_page_link.short_description = "View page"
+
+
+class BasePageAdmin(SetPageTypeMixin, RenderPageRegionsMixin, admin.ModelAdmin):
+    """
+    Base class for modeladmins for concrete page models. It provides the
+    following features:
+
+    - Set the initial value of the hidden page_type field in the page add form.
+    - Render an inline formset for each region of the page.
+    """

django_simple_page-1.0.0/simple_page/apps.py

@@ -0,0 +1,11 @@
+from django.apps import AppConfig
+
+
+class SimplePageConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'simple_page'
+    verbose_name = "Simple Page"
+
+
+    def ready(self):
+        import simple_page.signals

django_simple_page-1.0.0/simple_page/forms.py

@@ -0,0 +1,13 @@
+from django.forms import ModelForm, HiddenInput
+from reorder_items_widget import ReorderItemsWidget
+
+
+class ReorderRelationForm(ModelForm):
+    """
+    A ModelForm using the ReorderItemsWidget with an index field.
+    """
+    class Meta:
+        widgets = {
+            'index': ReorderItemsWidget(attrs={'class': 'hidden'}),
+            'region': HiddenInput(),
+        }

django_simple_page-1.0.0/simple_page/models.py

@@ -0,0 +1,192 @@
+"""
+Pages and sections are the basic building blocks of your website. Pages define
+regions in which sections can be placed. And sections can be any kind of content
+you want to see on your website.
+
+Pages and sections are defined by subclassing the :class:`~.models.Page` and
+:class:`~.models.Section` model::
+
+    from simple_page.models import Page, Section
+
+    class FancyPage(Page):
+        REGIONS = [
+            ('main', 'Main Region'),
+            ('sidebar', 'Sidebar'),
+            ('footer', 'Footer'),
+        ]
+
+        class Meta:
+            proxy = True
+
+
+    class FancySection(Section):
+        title = models.CharField(max_length=255, blank=True)
+        text = models.TextField(blank=True)
+
+
+With those two models you are able to build a simple website.
+"""
+
+from mptt.models import MPTTModel, TreeForeignKey
+from model_utils.managers import InheritanceManager
+
+from django.db import models
+from django.urls import reverse
+from django.contrib.contenttypes.models import ContentType
+
+
+class Section(models.Model):
+    """
+    Base model for what ever content you want to see on your website. It does
+    not has any fields by its own but can be equipped by sublcasses.
+
+    Sections are related to pages via a many-to-many relationship that holds the
+    region in which a section should be rendered and an index field to make the
+    sections orderable whithin that region.
+    """
+
+    objects = InheritanceManager()
+    """
+    We use the `InheritanceManager`_ to provide a simple api to access child
+    class objects.
+
+    .. _InheritanceManager: https://django-model-utils.readthedocs.io/en/latest/managers.html#inheritancemanager
+"""
+
+    def __str__(self):
+        if type(self) is Section:
+            child_self = self._meta.model.objects.get_subclass(id=self.id)
+            return f"{child_self._meta.verbose_name}: {child_self}"
+        else:
+            # FIXME: This leads to a recursive call if child_self is a Section
+            # as well. This happens when for any reason a section object has no
+            # child class.
+            return super().__str__()
+
+
+class Page(MPTTModel):
+    """
+    Base model for all pages.
+
+    The only thing a subclass has to do is to setup its :attr:`regions
+    <.Page.REGIONS>`. Since the database layout is fully functional, you may
+    define your own page model as a proxy if you do not want to provide
+    additional fields.
+
+    Sections associated with a page are accessible by their region. Use the
+    region's name to get a queryset of sections belonging to that region.
+
+    The page model is tree structured by `django-mptt`_.
+
+    .. _django-mptt: https://django-mptt.readthedocs.io/en/latest/
+    """
+
+    # FIXME: We should use REGIONS = None and raise a NotImplementedError. But
+    # tests are failing, since for any reason the get_regions method is called
+    # on a Page objects occacionally.
+    REGIONS = []
+    """
+    REGIONS must be set by subclasses as a list of tuples holding the region's
+    name and its title. Something like::
+
+        REGIONS = [
+            ('main', 'Main Region'),
+            ('sidebar', 'Sidebar'),
+            ('footer', 'Footer'),
+        ]
+    """
+
+    @classmethod
+    def get_regions(cls):
+        """
+        Return the regions for this page. This method can be customized by child
+        classes to return different regions.
+        """
+        return cls.REGIONS
+
+    def resolve_obj(self):
+        """
+        Return the instance of the child class.
+        """
+        model = self.page_type.model_class()
+        return model.objects.get(id=self.id)
+
+    title = models.CharField(max_length=255)
+    slug = models.SlugField(unique=True)
+    page_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    sections = models.ManyToManyField(
+        Section,
+        through="PageSection",
+        related_name="pages",
+        blank=True,
+    )
+    parent = TreeForeignKey(
+        "self",
+        null=True,
+        blank=True,
+        related_name="children",
+        on_delete=models.SET_NULL,
+    )
+
+    def get_absolute_url(self):
+        return reverse("page", kwargs={"slug": self.slug})
+
+    def __str__(self):
+        return self.title
+
+    def __getattr__(self, name):
+        """
+        If the attribute name is a region return its sections, otherwise raise
+        AttributeError.
+        """
+        if name in [region for region, _ in self.get_regions()]:
+            sections = self.sections.filter(pagesection__region=name)
+            return sections.select_subclasses().order_by("pagesection__index")
+        else:
+            msg = f"{self.__class__.__name__} object has no attribute '{name}'"
+            raise AttributeError(msg)
+
+
+class UpdateIndexesManager(models.Manager):
+    """
+    Provide methods to set the index of an newly saved object and to fix
+    indexes of a set of items from which one was deleted.
+    """
+    def set_index(self, obj):
+        """
+        If an object is about to be added we give him the next higher
+        index. Call this method from a pre-save signal handler.
+        """
+        items = self.filter(page=obj.page, region=obj.region)
+        max_index = items.aggregate(models.Max('index'))['index__max'] or 0
+        obj.index = max_index + 1
+
+    def update_indexes(self, obj):
+        """
+        If an object was deleted fix the indexes of following objects. Call this
+        method from a post-delete signal handler.
+        """
+        items = self.filter(page=obj.page, region=obj.region)
+        for item in items.filter(index__gt=obj.index):
+            item.index -= 1
+            item.save()
+
+
+class PageSection(models.Model):
+    """
+    PageSection is the intermediate model for the many-to-many relationship
+    between pages and sections. It holds the region in which a section should be
+    rendered and an index field to make sections orderable whithin that region.
+    """
+    objects = UpdateIndexesManager()
+
+    page = models.ForeignKey(Page, on_delete=models.CASCADE)
+    section = models.ForeignKey(Section, on_delete=models.CASCADE)
+    region = models.CharField('Region', max_length=255)
+    index = models.SmallIntegerField(blank=True)
+
+    class Meta:
+        ordering = ["page__id", "index"]
+
+    def __str__(self):
+        return f"{self.section}"

django_simple_page-1.0.0/simple_page/renderer.py

@@ -0,0 +1,294 @@
+"""
+To build HTML for a page or section object a renderer class is used. While a
+section renderer produces a html snippet representing the section object, a page
+renderer provides a full html document for a page. Including all its sections.
+
+Nevertheless, both renderers are based on the same concept, using the proven
+triad of `get_template_name`, `get_context` and `render` methods.
+
+There is a default renderer for pages as well as for sections. Which are
+probably sufficient for most use cases. Still you are free to write your own
+renderer classes and :func:`~.register` them for your page and section models.
+The only thing a renderer class has to provide is a `render` method returning
+valid HTML.
+
+Renderer classes using django's :class:`~django.forms.MediaDefiningClass` as
+metaclass. They can be equipped with a `Media` classes like django's forms and
+widgets::
+
+    class FancySectionRenderer(SectionRenderer):
+        class Media:
+            css = dict(all=['fancy_section.css'])
+            js = ['fancy_section.js']
+
+It is the responsibility of the page renderer to merge the media
+definitions of all renderers involved and provide them as a `media` template
+variable. For more details see :meth:`~.PageRenderer.get_media_assets`.
+"""
+
+import re
+from django.template.loader import get_template
+from django.forms.widgets import MediaDefiningClass
+from .models import Page
+
+
+REGISTRY = dict()
+
+def register(model_cls, renderer_cls=None, context=None):
+    """
+    Register a :class:`renderer class <.BaseRenderer>` for a page or section
+    model. This function can also be used as a decorator for your renderer
+    class::
+
+        @renderer.register(FancyPage)
+        class FancyPageRenderer(PageRenderer):
+            ...
+
+    :class:`Section renderer <.SectionRenderer>` can be applied context
+    specific. A context can be a page type, a region name or a tuple of page
+    type and region name::
+
+        @renderer.register(FancySection, context='main')
+        class MainRegionFancySectionRenderer(SectionRenderer):
+            ...
+
+    or::
+
+        @renderer.register(FancySection, context=(FancyPage, 'main'))
+        class FancyPageMainRegionFancySectionRenderer(SectionRenderer):
+            ...
+
+    This allows you to use different renderers depending on where a section
+    appears. See :func:`~.get_section_renderer` for more details about how a
+    renderer will be choosen.
+
+    :param model_cls: model to be rendered
+    :type model_cls: :class:`~.models.Page` or :class:`~.models.Section`
+    :param renderer_cls: renderer class
+    :type renderer_cls: :class:`~.PageRenderer` or :class:`~.SectionRenderer`
+    :param context: context where a section renderer should be applied
+    :type context: :class:`~.models.Page` or str or tuple of both, optional
+    """
+    def _register(renderer_cls):
+        if issubclass(model_cls, Page):
+            REGISTRY[model_cls] = renderer_cls
+        else:
+            REGISTRY[model_cls] = REGISTRY.get(model_cls) or dict()
+            REGISTRY[model_cls][context] = renderer_cls
+        return model_cls
+
+    # Usage as function.
+    if renderer_cls:
+        _register(renderer_cls)
+
+    # Usage as decorator.
+    else:
+        return _register
+
+
+def get_page_renderer(page):
+    """
+    Return the registered renderer for the page or :class:`~.PageRenderer`.
+
+    :param page: page instance to be rendered
+    :type page: :class:`~.models.Page`
+    :return: renderer class
+    :rtype: :class:`~.PageRenderer`
+    """
+    return REGISTRY.get(type(page), PageRenderer)
+
+
+def get_section_renderer(section, page=None, region=None):
+    """
+    Return a renderer instance for the section.
+
+    We look for a registered renderer in this order:
+
+    * page-type and region specific
+    * region specific
+    * page-type specific
+    * neither page-type nor region specific
+
+    The first one found will be returned. Otherwise the
+    :class:`~.SectionRenderer` is used as fallback.
+
+    :param obj: section instance
+    :type obj: :class:`~.models.Section`
+    :param page: page the section will be rendered for
+    :type page: :class:`~.models.Page`
+    :param str region: region the section  will be rendered in
+    :return: renderer class
+    :rtype: :class:`~.SectionRenderer`
+    """
+    if type(section) in REGISTRY:
+        # One of these keys must have been used to register a renderer class.
+        for key in [(type(page), region), region, type(page), None]:
+            if key in REGISTRY[type(section)]:
+                return REGISTRY[type(section)][key]
+    else:
+        return SectionRenderer
+
+
+class BaseRenderer(metaclass=MediaDefiningClass):
+    """
+    Base renderer class.
+    """
+
+    template_name = None
+    """
+    Template name. Default is None. See :meth:`~.get_template_name`.
+    """
+
+    def __init__(self, obj, request=None, **kwargs):
+        """
+        Initialize the renderer.
+
+        :param obj: object to be rendered
+        :type obj: :class:`~.models.Page` or :class:`~.models.Section`
+        :param request: request object (default: None)
+        :type request: :class:`~django.http.HttpRequest`
+        :param kwargs: Additional data as keyword arguments (default: dict())
+        """
+        self.obj = obj
+        self.request = request
+        self.kwargs = kwargs
+
+    def render(self):
+        """
+        Return the rendered HTML using the template and context returned by
+        :meth:`~.get_template_name` and :meth:`~.get_context` methods.
+        """
+        template = get_template(self.get_template_name())
+        context = self.get_context()
+        return template.render(context)
+
+
+class SectionRenderer(BaseRenderer):
+    """
+    Renderer for Section instances.
+    """
+    # TODO: Use a get_template method instead.
+    def get_template_name(self):
+        """
+        Return template name. If :attr:`~.template_name` is set it will be
+        returned. Otherwise the template name will be constructed as follows:
+
+        "sections/<section_class_name_in_snake_case>.html"
+        """
+        if self.template_name:
+            return self.template_name
+        else:
+            cls_name = self.obj.__class__.__name__
+            template_name = re.sub(r'(?<!^)(?=[A-Z])', '_', cls_name).lower()
+            return f'sections/{template_name}.html'
+
+    def get_context(self):
+        """
+        Build and return rendering context:
+
+        - `section`: section object
+
+        :return: rendering context
+        :rtype: dict
+        """
+        context = self.kwargs.get('extra_context', dict())
+        context['section'] = self.obj
+        return context
+
+
+class PageRenderer(BaseRenderer):
+    """
+    Renderer for Page instances.
+    """
+    def get_template_name(self):
+        """
+        Return template name. If :attr:`~.template_name` is set it will be
+        returned. Otherwise the template name will be constructed as follows:
+
+        "pages/<page_class_name_in_snake_case>.html"
+        """
+        if self.template_name:
+            return self.template_name
+        else:
+            cls_name = self.obj.__class__.__name__
+            template_name = re.sub(r'(?<!^)(?=[A-Z])', '_', cls_name).lower()
+            return f'pages/{template_name}.html'
+
+    def get_section_data(self, section, region):
+        """
+        Build and return a dictionary holding the section's data:
+
+        - `obj`: section object itself
+        - `html`: section's html build by the renderer returned by :func:`~.get_section_renderer`
+
+        :param section: section object
+        :type section: :class:`~.models.Section`
+        :param str region: region name
+        :return: section data holding the section object and the rendered html
+        :rtype: dict
+        """
+        renderer_cls = get_section_renderer(section, self.obj, region)
+        renderer = renderer_cls(section, self.request, **self.kwargs)
+        return dict(
+            obj=section,
+            html=renderer.render()
+        )
+
+    def get_region_data(self, region, title):
+        """
+        Build and return a dictionary holding the region's data:
+
+        - `name`: region name
+        - `title`: region title
+        - `sections`: list of section data build by :meth:`~.get_section_data`
+
+        :param str region: region name
+        :param str tilte: region title
+        :return: region data holding title, name and sections for this region
+        :rtype: dict
+        """
+        region_data = {'title': title, 'name': region, 'sections': []}
+        for section in getattr(self.obj, region):
+            section_data = self.get_section_data(section, region)
+            region_data['sections'].append(section_data)
+        return region_data
+
+    def get_media_assets(self):
+        """
+        Merge media definitions of the page's and all sections' renderers.
+        Return them as string.
+
+        :return str: merged media assets
+        """
+        media = get_page_renderer(self.obj)(self.obj).media
+        for region, _ in self.obj.get_regions():
+            for section in getattr(self.obj, region):
+                section_renderer = get_section_renderer(section, self.obj, region)
+                media += section_renderer(section).media
+        return str(media)
+
+    def get_context(self):
+        """
+        Build rendering context:
+
+        - `page`: page object
+        - `media`: media assets build by :meth:`~.get_media_assets`
+        - `regions`: mapping of region names to their data build by
+          :meth:`~.get_region_data`
+
+        As a shortcut each region data will also be added using the region's
+        name as an own context variable.
+
+        :return: rendering context
+        :rtype: dict
+        """
+        # Add regions, sections and media to the context.
+        context = self.kwargs.get('extra_context', dict())
+        context['page'] = self.obj
+        context['media'] = self.get_media_assets()
+        context['regions'] = dict()
+        for region, title in self.obj.get_regions():
+            context[region] = self.get_region_data(region, title)
+            context['regions'][region] = context[region]
+
+        return context

django_simple_page-1.0.0/simple_page/signals.py

@@ -0,0 +1,15 @@
+from django.db.models.signals import pre_save, post_delete
+from django.dispatch import receiver
+from .models import PageSection
+
+
+@receiver(pre_save, sender=PageSection)
+def pre_save_page_section(sender, instance, **kwargs):
+    # Ensure instance was added and not changed.
+    if instance.pk is None:
+        PageSection.objects.set_index(instance)
+
+
+@receiver(post_delete, sender=PageSection)
+def post_delete_page_section(sender, instance, **kwargs):
+    PageSection.objects.update_indexes(instance)

django_simple_page-1.0.0/simple_page/templates/admin/simple_page/page/change_form.html

@@ -0,0 +1,19 @@
+{% extends "admin/change_form.html" %}
+{% load i18n static %}
+
+{% block content %}
+    {% if page_types %}
+        <h2>{% translate "Choose page type" %}</h2>
+        <ul>
+            {% for url, name in page_types %}
+                <li>
+                    <a href="{{ url }}" class="addlink" role="button">
+                        {% translate "Add" %} {{ name }}
+                    </a>
+                </li>
+            {% endfor %}
+        </ul>
+    {% else %}
+        {{ block.super }}
+    {% endif %}
+{% endblock %}

django_simple_page-1.0.0/simple_page/templates/simple_page/menu.html

@@ -0,0 +1,18 @@
+{% load simple_page mptt_tags %}
+<ul class="nav-level-1">
+    {% if root %}
+        <li{% if page.is_root_node %} class="active"{% endif %}>
+            <a href="{{ root.get_absolute_url }}">{{ root.title }}</a>
+        </li>
+    {% endif %}
+    {% recursetree nodes %}
+        <li{% if page|is_active:node %} class="active"{% endif %}>
+            <a href="{{ node.get_absolute_url }}">{{ node.title }}</a>
+            {% if not node.is_leaf_node and not node|level > max_level%}
+                <ul class="nav-level-{{ node|level }}">
+                    {{ children }}
+                </ul>
+            {% endif %}
+        </li>
+    {% endrecursetree %}
+</ul>

django_simple_page-1.0.0/simple_page/views.py

@@ -0,0 +1,22 @@
+from django.shortcuts import get_object_or_404
+from django.http import HttpResponse
+from .models import Page
+from .renderer import get_page_renderer
+
+
+def page_view(request, slug, **kwargs):
+    """
+    Simple view function for pages. Get the page by its slug, find the right renderer
+    for it and return an HTTP response with the rendered page.
+
+    :param request: HTTP request
+    :type request: :class:`~django.http.HttpRequest`
+    :param str slug: slug of the page to be rendered
+    :param kwargs: Additional data as keyword arguments (default empty dict)
+    :return: HTTP response with the rendered page
+    :rtype: :class:`~django.http.HttpResponse`
+    :raises Http404: if no page with the given slug exists
+    """
+    page = get_object_or_404(Page, slug=slug).resolve_obj()
+    renderer_cls = get_page_renderer(page)
+    return HttpResponse(renderer_cls(page, request, **kwargs).render())