Django comes with an optional „flatpages” application. It lets you store simple\n„flat” HTML content in a database and handles the management for you via\nDjango’s admin interface and a Python API.
\nA flatpage is a simple object with a URL, title and content. Use it for\none-off, special-case pages, such as „About” or „Privacy Policy” pages, that\nyou want to store in a database but for which you don’t want to develop a\ncustom Django application.
\nA flatpage can use a custom template or a default, systemwide flatpage\ntemplate. It can be associated with one, or multiple, sites.
\nThe content field may optionally be left blank if you prefer to put your\ncontent in a custom template.
\nHere are some examples of flatpages on Django-powered sites:
\n\nTo install the flatpages app, follow these steps:
\nInstall the sites framework by adding\n'django.contrib.sites' to your INSTALLED_APPS setting,\nif it’s not already in there.
Also make sure you’ve correctly set SITE_ID to the ID of the\nsite the settings file represents. This will usually be 1 (i.e.\nSITE_ID = 1, but if you’re using the sites framework to manage\nmultiple sites, it could be the ID of a different site.
Add 'django.contrib.flatpages' to your INSTALLED_APPS\nsetting.
Then either:
\nAdd an entry in your URLconf. For example:
\nurlpatterns = [\n url(r'^pages/', include('django.contrib.flatpages.urls')),\n]\nor:
\nAdd 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware'\nto your MIDDLEWARE setting.
Run the command manage.py migrate.
manage.py migrate creates two tables in your database: django_flatpage\nand django_flatpage_sites. django_flatpage is a simple lookup table\nthat simply maps a URL to a title and bunch of text content.\ndjango_flatpage_sites associates a flatpage with a site.
There are several ways to include the flat pages in your URLconf. You can\ndedicate a particular path to flat pages:
\nurlpatterns = [\n url(r'^pages/', include('django.contrib.flatpages.urls')),\n]\nYou can also set it up as a „catchall” pattern. In this case, it is important\nto place the pattern at the end of the other urlpatterns:
\nfrom django.contrib.flatpages import views\n\n# Your other patterns here\nurlpatterns += [\n url(r'^(?P<url>.*/)$', views.flatpage),\n]\nAnother common setup is to use flat pages for a limited set of known pages and\nto hard code the urls, so you can reference them with the url template\ntag:
from django.contrib.flatpages import views\n\nurlpatterns += [\n url(r'^about-us/$', views.flatpage, {'url': '/about-us/'}, name='about'),\n url(r'^license/$', views.flatpage, {'url': '/license/'}, name='license'),\n]\nThe FlatpageFallbackMiddleware\ncan do all of the work.
Each time any Django application raises a 404 error, this middleware\nchecks the flatpages database for the requested URL as a last resort.\nSpecifically, it checks for a flatpage with the given URL with a site ID\nthat corresponds to the SITE_ID setting.
If it finds a match, it follows this algorithm:
\nIf the flatpage has a custom template, it loads that template.\nOtherwise, it loads the template flatpages/default.html.
It passes that template a single context variable, flatpage,\nwhich is the flatpage object. It uses\nRequestContext in rendering the\ntemplate.
The middleware will only add a trailing slash and redirect (by looking\nat the APPEND_SLASH setting) if the resulting URL refers to\na valid flatpage. Redirects are permanent (301 status code).
If it doesn’t find a match, the request continues to be processed as usual.
\nThe middleware only gets activated for 404s – not for 500s or responses\nof any other status code.
\nNote that the order of MIDDLEWARE matters. Generally, you can put\nFlatpageFallbackMiddleware at the\nend of the list. This means it will run first when processing the response, and\nensures that any other response-processing middleware see the real flatpage\nresponse rather than the 404.
For more on middleware, read the middleware docs.
\n\nIf you’ve activated the automatic Django admin interface, you should see a\n„Flatpages” section on the admin index page. Edit flatpages as you edit any\nother object in the system.
\nThe FlatPage model has an enable_comments field that isn’t used by\ncontrib.flatpages, but that could be useful for your project or third-party\napps. It doesn’t appear in the admin interface, but you can add it by\nregistering a custom ModelAdmin for FlatPage:
from django.contrib import admin\nfrom django.contrib.flatpages.admin import FlatPageAdmin\nfrom django.contrib.flatpages.models import FlatPage\nfrom django.utils.translation import ugettext_lazy as _\n\n# Define a new FlatPageAdmin\nclass FlatPageAdmin(FlatPageAdmin):\n fieldsets = (\n (None, {'fields': ('url', 'title', 'content', 'sites')}),\n (_('Advanced options'), {\n 'classes': ('collapse', ),\n 'fields': (\n 'enable_comments',\n 'registration_required',\n 'template_name',\n ),\n }),\n )\n\n# Re-register FlatPageAdmin\nadmin.site.unregister(FlatPage)\nadmin.site.register(FlatPage, FlatPageAdmin)\nFlatpages are represented by a standard\nDjango model,\nwhich lives in django/contrib/flatpages/models.py. You can access\nflatpage objects via the Django database API.
\nBy default, flatpages are rendered via the template\nflatpages/default.html, but you can override that for a\nparticular flatpage: in the admin, a collapsed fieldset titled\n„Advanced options” (clicking will expand it) contains a field for\nspecifying a template name. If you’re creating a flat page via the\nPython API you can simply set the template name as the field\ntemplate_name on the FlatPage object.
Creating the flatpages/default.html template is your responsibility;\nin your template directory, just create a flatpages directory\ncontaining a file default.html.
Flatpage templates are passed a single context variable, flatpage,\nwhich is the flatpage object.
Here’s a sample flatpages/default.html template:
<!DOCTYPE html>\n<html>\n<head>\n<title>{{ flatpage.title }}</title>\n</head>\n<body>\n{{ flatpage.content }}\n</body>\n</html>\nSince you’re already entering raw HTML into the admin page for a flatpage,\nboth flatpage.title and flatpage.content are marked as not\nrequiring automatic HTML escaping in the\ntemplate.
FlatPage objects in your templatesLink to this heading#The flatpages app provides a template tag that allows you to iterate\nover all of the available flatpages on the current site.
\nLike all custom template tags, you’ll need to load its custom\ntag library before you can use\nit. After loading the library, you can retrieve all current flatpages\nvia the get_flatpages tag:
{% load flatpages %}\n{% get_flatpages as flatpages %}\n<ul>\n {% for page in flatpages %}\n <li><a href="{{ page.url }}">{{ page.title }}</a></li>\n {% endfor %}\n</ul>\nregistration_required flatpagesLink to this heading#By default, the get_flatpages templatetag will only show\nflatpages that are marked registration_required = False. If you\nwant to display registration-protected flatpages, you need to specify\nan authenticated user using a for clause.
For example:
\n{% get_flatpages for someuser as about_pages %}\nIf you provide an anonymous user, get_flatpages will behave\nthe same as if you hadn’t provided a user – i.e., it will only show you\npublic flatpages.
An optional argument, starts_with, can be applied to limit the\nreturned pages to those beginning with a particular base URL. This\nargument may be passed as a string, or as a variable to be resolved\nfrom the context.
For example:
\n{% get_flatpages '/about/' as about_pages %}\n{% get_flatpages about_prefix as about_pages %}\n{% get_flatpages '/about/' for someuser as about_pages %}\ndjango.contrib.sitemapsLink to this heading#The sitemaps.FlatPageSitemap class looks at all\npublicly visible flatpages defined for the current\nSITE_ID (see the sites documentation) and creates an entry in the sitemap. These entries\ninclude only the location\nattribute – not lastmod,\nchangefreq or\npriority.
Here’s an example of a URLconf using FlatPageSitemap:
from django.conf.urls import url\nfrom django.contrib.flatpages.sitemaps import FlatPageSitemap\nfrom django.contrib.sitemaps.views import sitemap\n\nurlpatterns = [\n # ...\n\n # the sitemap\n url(r'^sitemap\\.xml$', sitemap,\n {'sitemaps': {'flatpages': FlatPageSitemap}},\n name='django.contrib.sitemaps.views.sitemap'),\n]\n