The flatpages app

Django comes with an optional “flatpages” application. It lets you store “flat” HTML content in a database and handles the management for you via Django’s admin interface and a Python API.

A flatpage is an object with a URL, title and content. Use it for one-off, special-case pages, such as “About” or “Privacy Policy” pages, that you want to store in a database but for which you don’t want to develop a custom Django application.

A flatpage can use a custom template or a default, systemwide flatpage template. It can be associated with one, or multiple, sites.

The content field may optionally be left blank if you prefer to put your content in a custom template.

Installation

To install the flatpages app, follow these steps:

  1. Install the sites framework by adding 'django.contrib.sites' to your INSTALLED_APPS setting, if it’s not already in there.

    Also make sure you’ve correctly set SITE_ID to the ID of the site the settings file represents. This will usually be 1 (i.e. SITE_ID = 1, but if you’re using the sites framework to manage multiple sites, it could be the ID of a different site.

  2. Add 'django.contrib.flatpages' to your INSTALLED_APPS setting.

Then either:

  1. Add an entry in your URLconf. For example:

    1. urlpatterns = [
    2.     path("pages/", include("django.contrib.flatpages.urls")),
    3. ]

or:

  1. Add 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware' to your MIDDLEWARE setting.
  2. Run the command manage.py migrate.

How it works

manage.py migrate creates two tables in your database: django_flatpage and django_flatpage_sites. django_flatpage is a lookup table that maps a URL to a title and bunch of text content. django_flatpage_sites associates a flatpage with a site.

Using the URLconf

There are several ways to include the flat pages in your URLconf. You can dedicate a particular path to flat pages:

  1. urlpatterns = [
  2.     path("pages/", include("django.contrib.flatpages.urls")),
  3. ]

You can also set it up as a “catchall” pattern. In this case, it is important to place the pattern at the end of the other urlpatterns:

  1. from django.contrib.flatpages import views
  3. # Your other patterns here
  4. urlpatterns += [
  5.     re_path(r"^(?P<url>.*/)$", views.flatpage),
  6. ]

Warning

If you set APPEND_SLASH to False, you must remove the slash in the catchall pattern or flatpages without a trailing slash will not be matched.

Another common setup is to use flat pages for a limited set of known pages and to hard code the urls, so you can reference them with the url template tag:

  1. from django.contrib.flatpages import views
  3. urlpatterns += [
  4.     path("about-us/", views.flatpage, {"url": "/about-us/"}, name="about"),
  5.     path("license/", views.flatpage, {"url": "/license/"}, name="license"),
  6. ]

Using the middleware

The FlatpageFallbackMiddleware can do all of the work.

class FlatpageFallbackMiddleware

Each time any Django application raises a 404 error, this middleware checks the flatpages database for the requested URL as a last resort. Specifically, it checks for a flatpage with the given URL with a site ID that corresponds to the SITE_ID setting.

If it finds a match, it follows this algorithm:

  • If the flatpage has a custom template, it loads that template. Otherwise, it loads the template flatpages/default.html.
  • It passes that template a single context variable, flatpage, which is the flatpage object. It uses RequestContext in rendering the template.

The middleware will only add a trailing slash and redirect (by looking at the APPEND_SLASH setting) if the resulting URL refers to a valid flatpage. Redirects are permanent (301 status code).

If it doesn’t find a match, the request continues to be processed as usual.

The middleware only gets activated for 404s – not for 500s or responses of any other status code.

Flatpages will not apply view middleware

Because the FlatpageFallbackMiddleware is applied only after URL resolution has failed and produced a 404, the response it returns will not apply any view middleware methods. Only requests which are successfully routed to a view via normal URL resolution apply view middleware.

Note that the order of MIDDLEWARE matters. Generally, you can put FlatpageFallbackMiddleware at the end of the list. This means it will run first when processing the response, and ensures that any other response-processing middleware see the real flatpage response rather than the 404.

For more on middleware, read the middleware docs.

Ensure that your 404 template works

Note that the FlatpageFallbackMiddleware only steps in once another view has successfully produced a 404 response. If another view or middleware class attempts to produce a 404 but ends up raising an exception instead, the response will become an HTTP 500 (“Internal Server Error”) and the FlatpageFallbackMiddleware will not attempt to serve a flat page.

How to add, change and delete flatpages

Warning

Permissions to add or edit flatpages should be restricted to trusted users. Flatpages are defined by raw HTML and are not sanitized by Django. As a consequence, a malicious flatpage can lead to various security vulnerabilities, including permission escalation.

Via the admin interface

If you’ve activated the automatic Django admin interface, you should see a “Flatpages” section on the admin index page. Edit flatpages as you edit any other object in the system.

The FlatPage model has an enable_comments field that isn’t used by contrib.flatpages, but that could be useful for your project or third-party apps. It doesn’t appear in the admin interface, but you can add it by registering a custom ModelAdmin for FlatPage:

  1. from django.contrib import admin
  2. from django.contrib.flatpages.admin import FlatPageAdmin
  3. from django.contrib.flatpages.models import FlatPage
  4. from django.utils.translation import gettext_lazy as _
  7. # Define a new FlatPageAdmin
  8. class FlatPageAdmin(FlatPageAdmin):
  9.     fieldsets = [
  10.         (None, {"fields": ["url", "title", "content", "sites"]}),
  11.         (
  12.             _("Advanced options"),
  13.             {
  14.                 "classes": ["collapse"],
  15.                 "fields": [
  16.                     "enable_comments",
  17.                     "registration_required",
  18.                     "template_name",
  19.                 ],
  20.             },
  21.         ),
  22.     ]
  25. # Re-register FlatPageAdmin
  26. admin.site.unregister(FlatPage)
  27. admin.site.register(FlatPage, FlatPageAdmin)

Via the Python API

class FlatPage

Flatpages are represented by a standard Django model, which lives in django/contrib/flatpages/models.py. You can access flatpage objects via the Django database API.

Check for duplicate flatpage URLs.

If you add or modify flatpages via your own code, you will likely want to check for duplicate flatpage URLs within the same site. The flatpage form used in the admin performs this validation check, and can be imported from django.contrib.flatpages.forms.FlatpageForm and used in your own views.

Flatpage templates

By default, flatpages are rendered via the template flatpages/default.html, but you can override that for a particular flatpage: in the admin, a collapsed fieldset titled “Advanced options” (clicking will expand it) contains a field for specifying a template name. If you’re creating a flat page via the Python API you can set the template name as the field template_name on the FlatPage object.

Creating the flatpages/default.html template is your responsibility; in your template directory, create a flatpages directory containing a file default.html.

Flatpage templates are passed a single context variable, flatpage, which is the flatpage object.

Here’s a sample flatpages/default.html template:

  1. <!DOCTYPE html>
  2. <html>
  3. <head>
  4. <title>{{ flatpage.title }}</title>
  5. </head>
  6. <body>
  7. {{ flatpage.content }}
  8. </body>
  9. </html>

Since you’re already entering raw HTML into the admin page for a flatpage, both flatpage.title and flatpage.content are marked as not requiring automatic HTML escaping in the template.

Getting a list of FlatPage objects in your templates

The flatpages app provides a template tag that allows you to iterate over all of the available flatpages on the current site.

Like all custom template tags, you’ll need to load its custom tag library before you can use it. After loading the library, you can retrieve all current flatpages via the get_flatpages tag:

  1. {% load flatpages %}
  2. {% get_flatpages as flatpages %}
  3. <ul>
  4.     {% for page in flatpages %}
  5.         <li><a href="{{ page.url }}">{{ page.title }}</a></li>
  6.     {% endfor %}
  7. </ul>

Displaying registration_required flatpages

By default, the get_flatpages template tag will only show flatpages that are marked registration_required = False. If you want to display registration-protected flatpages, you need to specify an authenticated user using a for clause.

For example:

  1. {% get_flatpages for someuser as about_pages %}

If you provide an anonymous user, get_flatpages will behave the same as if you hadn’t provided a user – i.e., it will only show you public flatpages.

Limiting flatpages by base URL

An optional argument, starts_with, can be applied to limit the returned pages to those beginning with a particular base URL. This argument may be passed as a string, or as a variable to be resolved from the context.

For example:

  1. {% get_flatpages '/about/' as about_pages %}
  2. {% get_flatpages about_prefix as about_pages %}
  3. {% get_flatpages '/about/' for someuser as about_pages %}

Integrating with django.contrib.sitemaps

class FlatPageSitemap

The sitemaps.FlatPageSitemap class looks at all publicly visible flatpages defined for the current SITE_ID (see the sites documentation) and creates an entry in the sitemap. These entries include only the location attribute – not lastmod, changefreq or priority.

Example

Here’s an example of a URLconf using FlatPageSitemap:

  1. from django.contrib.flatpages.sitemaps import FlatPageSitemap
  2. from django.contrib.sitemaps.views import sitemap
  3. from django.urls import path
  5. urlpatterns = [
  6.     # ...
  7.     # the sitemap
  8.     path(
  9.         "sitemap.xml",
  10.         sitemap,
  11.         {"sitemaps": {"flatpages": FlatPageSitemap}},
  12.         name="django.contrib.sitemaps.views.sitemap",
  13.     ),
  14. ]